UnitTest_Define.f90

Go to the documentation of this file.

!
! UnitTest_Define
!
! Module defining the UnitTest object
!
!
! CREATION HISTORY:
!       Written by:     Paul van Delst, 05-Feb-2007
!                       paul.vandelst@noaa.gov
!

MODULE unittest_define

  ! ------------------
  ! Environment setup
  ! -----------------
  ! Module usage
  USE type_kinds           , ONLY: byte, short, long, single, double
  USE compare_float_numbers, ONLY: OPERATOR(.equalto.)
  ! Disable implicit typing
  IMPLICIT NONE

  ! ------------
  ! Visibilities
  ! ------------
  ! Everything private by default
  PRIVATE
  ! Datatypes
  PUBLIC :: unittest_type
  ! Procedures
  PUBLIC :: unittest_init
  PUBLIC :: unittest_setup
  PUBLIC :: unittest_report
  PUBLIC :: unittest_summary
  PUBLIC :: unittest_n_passed
  PUBLIC :: unittest_n_failed
  PUBLIC :: unittest_passed
  PUBLIC :: unittest_failed
  PUBLIC :: unittest_assert
  PUBLIC :: unittest_isequal
  PUBLIC :: unittest_isequalwithin
  PUBLIC :: unittest_defineversion


  ! ---------------------
  ! Procedure overloading
  ! ---------------------
  ! PUBLIC procedures
  INTERFACE unittest_isequal
    ! INTEGER(Byte) procedures
    MODULE PROCEDURE intbyte_isequal_scalar
    MODULE PROCEDURE intbyte_isequal_rank1
    MODULE PROCEDURE intbyte_isequal_rank2
    ! INTEGER(Short) procedures
    MODULE PROCEDURE intshort_isequal_scalar
    MODULE PROCEDURE intshort_isequal_rank1
    MODULE PROCEDURE intshort_isequal_rank2
    ! INTEGER(Long) procedures
    MODULE PROCEDURE intlong_isequal_scalar
    MODULE PROCEDURE intlong_isequal_rank1
    MODULE PROCEDURE intlong_isequal_rank2
    ! REAL(Single) procedures
    MODULE PROCEDURE realsp_isequal_scalar
    MODULE PROCEDURE realsp_isequal_rank1
    MODULE PROCEDURE realsp_isequal_rank2
    ! REAL(Double) procedures
    MODULE PROCEDURE realdp_isequal_scalar
    MODULE PROCEDURE realdp_isequal_rank1
    MODULE PROCEDURE realdp_isequal_rank2
    ! COMPLEX(Single) procedures
    MODULE PROCEDURE complexsp_isequal_scalar
    MODULE PROCEDURE complexsp_isequal_rank1
    MODULE PROCEDURE complexsp_isequal_rank2
    ! COMPLEX(Double) procedures
    MODULE PROCEDURE complexdp_isequal_scalar
    MODULE PROCEDURE complexdp_isequal_rank1
    MODULE PROCEDURE complexdp_isequal_rank2
    ! CHARACTER(*) procedures
    MODULE PROCEDURE char_isequal_scalar
    MODULE PROCEDURE char_isequal_rank1
    MODULE PROCEDURE char_isequal_rank2
  END INTERFACE unittest_isequal

  INTERFACE unittest_isequalwithin
    ! REAL(Single) procedures
    MODULE PROCEDURE realsp_isequalwithin_scalar
    MODULE PROCEDURE realsp_isequalwithin_rank1
    MODULE PROCEDURE realsp_isequalwithin_rank2
    ! REAL(Double) procedures
    MODULE PROCEDURE realdp_isequalwithin_scalar
    MODULE PROCEDURE realdp_isequalwithin_rank1
    MODULE PROCEDURE realdp_isequalwithin_rank2
    ! COMPLEX(Single) procedures
    MODULE PROCEDURE complexsp_isequalwithin_scalar
    MODULE PROCEDURE complexsp_isequalwithin_rank1
    MODULE PROCEDURE complexsp_isequalwithin_rank2
    ! COMPLEX(Double) procedures
    MODULE PROCEDURE complexdp_isequalwithin_scalar
    MODULE PROCEDURE complexdp_isequalwithin_rank1
    MODULE PROCEDURE complexdp_isequalwithin_rank2
  END INTERFACE unittest_isequalwithin


  ! PRIVATE procedures
  INTERFACE get_multiplier
    MODULE PROCEDURE realsp_get_multiplier
    MODULE PROCEDURE realdp_get_multiplier
  END INTERFACE get_multiplier


  ! -----------------
  ! Module parameters
  ! -----------------
  CHARACTER(*), PARAMETER :: module_version_id = &
  '$Id: UnitTest_Define.f90 60152 2015-08-13 19:19:13Z paul.vandelst@noaa.gov $'
  INTEGER,      PARAMETER :: sl = 512
  INTEGER,      PARAMETER :: cr = 13
  INTEGER,      PARAMETER :: lf = 10
  CHARACTER(2), PARAMETER :: crlf = achar(cr)//achar(lf)
  CHARACTER(*), PARAMETER :: rfmt = 'es25.18'
  CHARACTER(*), PARAMETER :: zfmt = '"(",'//rfmt//',",",'//rfmt//',")"'
  LOGICAL,      PARAMETER :: default_verbose = .false.

  ! Message colours
  CHARACTER(*), PARAMETER :: green_colour = achar(27)//'[1;32m'
  CHARACTER(*), PARAMETER :: red_colour   = achar(27)//'[1;31m'
  CHARACTER(*), PARAMETER :: no_colour    = achar(27)//'[0m'

  ! Message levels
  INTEGER, PARAMETER :: n_message_levels = 6
  INTEGER, PARAMETER :: init_level          = 1
  INTEGER, PARAMETER :: setup_level         = 2
  INTEGER, PARAMETER :: test_level          = 3
  INTEGER, PARAMETER :: report_level        = 4
  INTEGER, PARAMETER :: summary_level       = 5
  INTEGER, PARAMETER :: internal_fail_level = 6
  CHARACTER(*), PARAMETER :: message_level(n_message_levels) = &
    [ 'INIT            ', &
      'SETUP           ', &
      'TEST            ', &
      'REPORT          ', &
      'SUMMARY         ', &
      'INTERNAL FAILURE' ]

  ! ------------------------
  ! Derived type definitions
  ! ------------------------
  !:tdoc+:
  TYPE :: unittest_type
    PRIVATE
    ! User accessible test settings
    LOGICAL       :: verbose = default_verbose
    CHARACTER(SL) :: title   = ''
    CHARACTER(SL) :: caller  = ''
    ! Internal test settings
    ! ...Test result messaging
    INTEGER       :: level     = init_level
    CHARACTER(SL) :: Procedure = ''
    CHARACTER(SL) :: message   = ''
    ! ...Test result (used for array argument procedures)
    LOGICAL :: test_result = .true.
    ! ...Individual test counters
    INTEGER :: n_tests        = 0
    INTEGER :: n_passed_tests = 0
    INTEGER :: n_failed_tests = 0
    ! ...All test counters
    INTEGER :: n_alltests        = 0
    INTEGER :: n_passed_alltests = 0
    INTEGER :: n_failed_alltests = 0
  END TYPE unittest_type
  !:tdoc-:

CONTAINS


!################################################################################
!################################################################################
!##                                                                            ##
!##                         ## PUBLIC MODULE ROUTINES ##                       ##
!##                                                                            ##
!################################################################################
!################################################################################

!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Init
!
! PURPOSE:
!       UnitTest initialisation subroutine.
!
!       This subroutine should be called ONCE, BEFORE ANY tests are performed.
!
! CALLING SEQUENCE:
!       CALL UnitTest_Init( UnitTest, Verbose=Verbose )
!
! OBJECTS:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(OUT)
!
! OPTIONAL INPUTS:
!       Verbose:       Logical argument to control length of reporting output.
!                      If == .FALSE., Only failed tests are reported [DEFAULT].
!                         == .TRUE.,  Both failed and passed tests are reported.
!                      If not specified, default is .TRUE.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN), OPTIONAL
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE unittest_init( UnitTest, Verbose )
    ! Arguments
    TYPE(unittest_type), INTENT(OUT) :: unittest
    LOGICAL,   OPTIONAL, INTENT(IN)  :: verbose
    ! Parameters
    CHARACTER(*), PARAMETER :: procedure_name = 'UnitTest_Init'
    ! Variables
    LOGICAL :: local_verbose

    ! Check optional arguments
    local_verbose = default_verbose
    IF ( PRESENT(verbose) ) local_verbose = verbose

    ! Perform initialisation
    CALL set_property( &
      unittest, &
      verbose = local_verbose, &
      level     = init_level, &
      Procedure = procedure_name, &
      n_tests        = 0, &
      n_passed_tests = 0, &
      n_failed_tests = 0, &
      n_alltests        = 0, &
      n_passed_alltests = 0, &
      n_failed_alltests = 0  )
    CALL display_message( unittest )
  END SUBROUTINE unittest_init


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Setup
!
! PURPOSE:
!       UnitTest individual test setup subroutine.
!
!       This subroutine should be called BEFORE each set of tests performed.
!
! CALLING SEQUENCE:
!       CALL UnitTest_Setup( UnitTest         , &
!                            Title            , &
!                            Caller  = Caller , &
!                            Verbose = Verbose  )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
! INPUTS:
!       Title:         Character string containing the title of the test
!                      to be performed.
!                      UNITS:      N/A
!                      TYPE:       CHARACTER(*)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       Caller:        Character string containing the name of the calling
!                      subprogram. If not specified, default is an empty string.
!                      UNITS:      N/A
!                      TYPE:       CHARACTER(*)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Verbose:       Logical argument to control length of reporting output.
!                      If == .FALSE., Only failed tests are reported [DEFAULT].
!                         == .TRUE.,  Both failed and passed tests are reported.
!                      If not specified, default is .TRUE.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN), OPTIONAL
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE unittest_setup( UnitTest, Title, Caller, Verbose )
    ! Arguments
    TYPE(unittest_type)   , INTENT(IN OUT) :: unittest
    CHARACTER(*)          , INTENT(IN)     :: title
    CHARACTER(*), OPTIONAL, INTENT(IN)     :: caller
    LOGICAL,      OPTIONAL, INTENT(IN)     :: verbose
    ! Parameters
    CHARACTER(*), PARAMETER :: procedure_name = 'UnitTest_Setup'
    ! Variables
    CHARACTER(SL) :: local_caller
    LOGICAL       :: local_verbose
    CHARACTER(SL) :: message

    ! Check arguments
    local_caller = ''
    IF ( PRESENT(caller) ) local_caller = '; CALLER: '//trim(adjustl(caller))
    local_verbose = default_verbose
    IF ( PRESENT(verbose) ) local_verbose = verbose

    ! Create init message
    message = trim(title)//trim(local_caller)

    ! Perform initialistion
    CALL set_property( &
      unittest, &
      title   = adjustl(title), &
      caller  = local_caller  , &
      verbose = local_verbose , &
      level     = setup_level, &
      Procedure = procedure_name, &
      message = message, &
      n_tests        = 0, &
      n_passed_tests = 0, &
      n_failed_tests = 0  )
    CALL display_message( unittest )

  END SUBROUTINE unittest_setup


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Report
!
! PURPOSE:
!       UnitTest individual test report subroutine
!
!       This subroutine should be called AFTER each set of tests performed.
!
! CALLING SEQUENCE:
!       CALL UnitTest_Report( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE unittest_report( UnitTest )
    ! Arguments
    TYPE(unittest_type), INTENT(IN OUT) :: unittest
    ! Parameters
    CHARACTER(*), PARAMETER :: procedure_name = 'UnitTest_Report'
    ! Variables
    INTEGER :: n_tests
    INTEGER :: n_passed_tests
    INTEGER :: n_failed_tests
    CHARACTER(SL) :: message
    CHARACTER(SL) :: attention
    CHARACTER(SL) :: colour
    ! Retrieve required properties
    CALL get_property( &
      unittest, &
      n_tests        = n_tests       , &
      n_passed_tests = n_passed_tests, &
      n_failed_tests = n_failed_tests  )

    ! Test fail attention-grabber
    colour    = green_colour
    attention = ''
    IF ( n_failed_tests /= 0 ) THEN
      colour    = red_colour
      attention = '  <----<<<  **WARNING**'
    END IF

    ! Output results
    WRITE( message, &
      '(a,a,3x,"Passed ",i0," of ",i0," tests", &
         &a,3x,"Failed ",i0," of ",i0," tests",a,a)') &
      trim(colour), crlf, &
      n_passed_tests, n_tests, &
      crlf, &
      n_failed_tests, n_tests, &
      trim(attention), no_colour
    CALL set_property( &
      unittest, &
      level = report_level, &
      Procedure = procedure_name, &
      message = message )
    CALL display_message( unittest )

  END SUBROUTINE unittest_report


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Summary
!
! PURPOSE:
!       UnitTest test suite report summary subroutine
!
!       This subroutine should be called ONCE, AFTER ALL tests are performed.
!
! CALLING SEQUENCE:
!       CALL UnitTest_Summary( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE unittest_summary( UnitTest )
    ! Arguments
    TYPE(unittest_type), INTENT(IN OUT) :: unittest
    ! Parameters
    CHARACTER(*), PARAMETER :: procedure_name = 'UnitTest_Summary'
    ! Variables
    INTEGER :: n_alltests
    INTEGER :: n_passed_alltests
    INTEGER :: n_failed_alltests
    CHARACTER(SL) :: message
    CHARACTER(SL) :: attention
    CHARACTER(SL) :: colour

    ! Retrieve required properties
    CALL get_property( &
      unittest, &
      n_alltests        = n_alltests       , &
      n_passed_alltests = n_passed_alltests, &
      n_failed_alltests = n_failed_alltests  )

    ! Test fail attention-grabber
    colour    = green_colour
    attention = ''
    IF ( n_failed_alltests /= 0 ) THEN
      colour    = red_colour
      attention = '  <----<<<  **WARNING**'
    END IF

    ! Output results
    WRITE( message, &
      '(a,a,1x,"Passed ",i0," of ",i0," total tests",&
         &a,1x,"Failed ",i0," of ",i0," total tests",a,a)') &
      trim(colour), crlf, &
      n_passed_alltests, n_alltests, &
      crlf, &
      n_failed_alltests, n_alltests, &
      trim(attention), no_colour
    CALL set_property( &
      unittest, &
      level = summary_level, &
      Procedure = procedure_name, &
      message = message )
    CALL display_message( unittest )
  END SUBROUTINE unittest_summary


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_n_Passed
!
! PURPOSE:
!       Utility function to return the number of tests passed.
!
! CALLING SEQUENCE:
!       n = UnitTest_n_Passed( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       n:             The number of unit tests that have currently passed.
!                      UNITS:      N/A
!                      TYPE:       INTEGER
!                      DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  PURE FUNCTION unittest_n_passed( UnitTest ) RESULT( n )
    TYPE(unittest_type), INTENT(IN) :: unittest
    INTEGER :: n
    CALL get_property( unittest, n_passed_tests = n )
  END FUNCTION unittest_n_passed


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_n_Failed
!
! PURPOSE:
!       Utility function to return the number of tests failed.
!
! CALLING SEQUENCE:
!       n = UnitTest_n_Failed( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       n:             The number of unit tests that have currently failed.
!                      UNITS:      N/A
!                      TYPE:       INTEGER
!                      DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  PURE FUNCTION unittest_n_failed( UnitTest ) RESULT( n )
    TYPE(unittest_type), INTENT(IN) :: unittest
    INTEGER :: n
    CALL get_property( unittest, n_failed_tests = n )
  END FUNCTION unittest_n_failed


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Passed
!
! PURPOSE:
!       Function to inform if the last test performed passed.
!
! CALLING SEQUENCE:
!       result = UnitTest_Passed( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       result:        Logical to indicate if the last test performed passed.
!                      If == .TRUE.,  the last test passed,
!                         == .FALSE., the last test failed.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  PURE FUNCTION unittest_passed( UnitTest ) RESULT( Passed )
    TYPE(unittest_type), INTENT(IN) :: unittest
    LOGICAL :: passed
    CALL get_property( unittest, test_result = passed )
  END FUNCTION unittest_passed


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Failed
!
! PURPOSE:
!       Function to inform if the last test performed failed.
!
!       Syntactic sugar procedure.
!
! CALLING SEQUENCE:
!       result = UnitTest_Failed( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       result:        Logical to indicate if the last test performed failed.
!                      If == .TRUE.,  the last test failed,
!                         == .FALSE., the last test passed.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!
!:sdoc-:
!------------------------------------------------------------------------------

  PURE FUNCTION unittest_failed( UnitTest ) RESULT( Failed )
    TYPE(unittest_type), INTENT(IN) :: unittest
    LOGICAL :: failed
    failed = .NOT. unittest_passed( unittest )
  END FUNCTION unittest_failed


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_Assert
!
! PURPOSE:
!       Subroutine to assert its test argument
!
! CALLING SEQUENCE:
!       CALL UnitTest_Assert(UnitTest, Test)
!
! OBJECTS:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
! INPUTS:
!       Test:          The logical expression to assert.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE unittest_assert(UnitTest, Test)
    ! Arguments
    TYPE(unittest_type), INTENT(IN OUT) :: unittest
    LOGICAL,             INTENT(IN)     :: test
    ! Parameters
    CHARACTER(*), PARAMETER :: procedure_name = 'UnitTest_Assert'
    ! Variables
    LOGICAL :: verbose
    CHARACTER(SL) :: message

    ! Setup
    message = ''
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure

    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    CALL test_info_string( unittest, message )
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )

  END SUBROUTINE unittest_assert


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_IsEqual
!
! PURPOSE:
!       Subroutine to assert that two arguments are equal.
!
! CALLING SEQUENCE:
!       CALL UnitTest_IsEqual( UnitTest, Expected, Actual )
!
! OBJECTS:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
! INPUTS:
!       Expected:      The expected value of the variable being tested.
!                      UNITS:      N/A
!                      TYPE:       INTEGER(Byte)  , or
!                                  INTEGER(Short) , or
!                                  INTEGER(Long)  , or
!                                  REAL(Single)   , or
!                                  REAL(Double)   , or
!                                  COMPLEX(Single), or
!                                  COMPLEX(Double), or
!                                  CHARACTER(*)
!                      DIMENSION:  Scalar, or
!                                  Rank-1, or
!                                  Rank-2
!                      ATTRIBUTES: INTENT(IN)
!
!       Actual:        The actual value of the variable being tested.
!                      UNITS:      N/A
!                      TYPE:       Same as Expected input
!                      DIMENSION:  Same as Expected input
!                      ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE intbyte_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Byte),       INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Byte)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected == actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message,'("Expected ",i0," and got ",i0)') expected, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE intbyte_isequal_scalar


  SUBROUTINE intbyte_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Byte),       INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Byte)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL intbyte_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE intbyte_isequal_rank1


  SUBROUTINE intbyte_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Byte),       INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Byte)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL intbyte_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE intbyte_isequal_rank2


  SUBROUTINE intshort_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Short),      INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Short)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected == actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message,'("Expected ",i0," and got ",i0)') expected, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE intshort_isequal_scalar


  SUBROUTINE intshort_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Short),      INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Short)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL intshort_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE intshort_isequal_rank1


  SUBROUTINE intshort_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Short),      INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Short)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL intshort_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE intshort_isequal_rank2


  SUBROUTINE intlong_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Long),       INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Long)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected == actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message,'("Expected ",i0," and got ",i0)') expected, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE intlong_isequal_scalar


  SUBROUTINE intlong_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Long),       INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Long)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL intlong_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE intlong_isequal_rank1


  SUBROUTINE intlong_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER(Long),       INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[INTEGER(Long)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL intlong_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE intlong_isequal_rank2


  SUBROUTINE realsp_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Single),        INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[REAL(Single)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected .equalto. actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected: ",'//rfmt//',a,&
         &7x,"And got:  ",'//rfmt//')') &
      crlf, expected, crlf, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE realsp_isequal_scalar


  SUBROUTINE realsp_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Single),        INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[REAL(Single)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL realsp_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE realsp_isequal_rank1


  SUBROUTINE realsp_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Single),        INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[REAL(Single)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL realsp_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE realsp_isequal_rank2


  SUBROUTINE realdp_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Double),        INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[REAL(Double)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected .equalto. actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected: ",'//rfmt//',a,&
         &7x,"And got:  ",'//rfmt//')') &
      crlf, expected, crlf, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE realdp_isequal_scalar


  SUBROUTINE realdp_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Double),        INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[REAL(Double)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL realdp_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE realdp_isequal_rank1


  SUBROUTINE realdp_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Double),        INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[REAL(Double)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL realdp_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE realdp_isequal_rank2


  SUBROUTINE complexsp_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Single),     INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[COMPLEX(Single)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected .equalto. actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected: ",'//zfmt//',a,&
         &7x,"And got:  ",'//zfmt//')') &
      crlf, expected, crlf, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE complexsp_isequal_scalar


  SUBROUTINE complexsp_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Single),     INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[COMPLEX(Single)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL complexsp_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE complexsp_isequal_rank1


  SUBROUTINE complexsp_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Single),     INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[COMPLEX(Single)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL complexsp_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE complexsp_isequal_rank2


  SUBROUTINE complexdp_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Double),     INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[COMPLEX(Double)]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected .equalto. actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected: ",'//zfmt//',a,&
         &7x,"And got:  ",'//zfmt//')') &
      crlf, expected, crlf, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE complexdp_isequal_scalar


  SUBROUTINE complexdp_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Double),     INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[COMPLEX(Double)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL complexdp_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE complexdp_isequal_rank1


  SUBROUTINE complexdp_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Double),     INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[COMPLEX(Double)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL complexdp_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE complexdp_isequal_rank2


  SUBROUTINE char_isequal_scalar( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    CHARACTER(*),        INTENT(IN)     :: Expected, Actual
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[CHARACTER]'
    ! Variables
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Assign the test
    test = (expected == actual)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message,'("Expected >",a,"< and got >",a,"<")') expected, actual
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE char_isequal_scalar


  SUBROUTINE char_isequal_rank1( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    CHARACTER(*),        INTENT(IN)     :: Expected(:), Actual(:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[CHARACTER]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0)') &
        isize, SIZE(actual)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL char_isequal_scalar( unittest, expected(i), actual(i) )
    END DO
  END SUBROUTINE char_isequal_rank1


  SUBROUTINE char_isequal_rank2( UnitTest, Expected, Actual )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    CHARACTER(*),        INTENT(IN)     :: Expected(:,:), Actual(:,:)
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqual[CHARACTER]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL char_isequal_scalar( unittest, expected(i,j), actual(i,j) )
      END DO
    END DO
  END SUBROUTINE char_isequal_rank2


!------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_IsEqualWithin
!
! PURPOSE:
!       Subroutine to assert that two floating point arguments are equal to
!       within the specified tolerance.
!
! CALLING SEQUENCE:
!       CALL UnitTest_IsEqualWithin( UnitTest , &
!                                    Expected , &
!                                    Actual   , &
!                                    Tolerance, &
!                                    Epsilon_Scale = Epsilon_Scale )
!
! OBJECTS:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
! INPUTS:
!       Expected:      The expected value of the variable being tested.
!                      UNITS:      N/A
!                      TYPE:       REAL(Single)   , or
!                                  REAL(Double)   , or
!                                  COMPLEX(Single), or
!                                  COMPLEX(Double)
!                      DIMENSION:  Scalar, or
!                                  Rank-1, or
!                                  Rank-2
!                      ATTRIBUTES: INTENT(IN)
!
!       Actual:        The actual value of the variable being tested.
!                      UNITS:      N/A
!                      TYPE:       Same as Expected input
!                      DIMENSION:  Same as Expected input
!                      ATTRIBUTES: INTENT(IN)
!
!       Tolerance:     The tolerance to within which the Expected and Actual
!                      values must agree. If negative, the value of
!                        EPSILON(Expected)
!                      is used.
!                      This argument is ignored if the EPSILON_SCALE optional
!                      argument is specified
!                      UNITS:      N/A
!                      TYPE:       Same as Expected input
!                      DIMENSION:  Same as Expected input
!                      ATTRIBUTES: INTENT(IN)
!
! OPTIONAL INPUTS:
!       Epsilon_Scale: Set this logical flag to compute and use the tolerance
!                      value:
!                        EPSILON(Expected) * Scale_Factor
!                      where the scaling factor is the exponent value of the
!                      input argument Expected.
!                      UNITS:      N/A
!                      TYPE:       LOGICAL.
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
!:sdoc-:
!------------------------------------------------------------------------------

  SUBROUTINE realsp_isequalwithin_scalar( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Single),        INTENT(IN)     :: Expected, Actual, Tolerance
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[REAL(Single)]'
    ! Variables
    REAL(Single) :: tol
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Default tolerance
    tol = tolerance
    ! ...Check optional arguments
    IF ( PRESENT(epsilon_scale) ) THEN
      IF ( epsilon_scale ) tol = epsilon(expected) * get_multiplier( expected )
    END IF
    ! ...Assign the test
    test = (abs(expected-actual) < tol)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected:     ",'//rfmt//',a,&
         &7x,"To within:    ",'//rfmt//',a,&
         &7x,"And got:      ",'//rfmt//',a,&
         &7x,"|Difference|: ",'//rfmt//')') &
      crlf, expected, crlf, tol, crlf, actual, crlf, abs(expected-actual)
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE realsp_isequalwithin_scalar


  SUBROUTINE realsp_isequalwithin_rank1(  &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Single),        INTENT(IN)     :: Expected(:), Actual(:), Tolerance(:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[REAL(Single)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual)    /= isize .OR. &
         SIZE(tolerance) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0,"; Tolerance:",i0)') &
        isize, SIZE(actual), SIZE(tolerance)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL realsp_isequalwithin_scalar( &
        unittest    , &
        expected(i) , &
        actual(i)   , &
        tolerance(i), &
        epsilon_scale = epsilon_scale )
    END DO
  END SUBROUTINE realsp_isequalwithin_rank1


  SUBROUTINE realsp_isequalwithin_rank2( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Single),        INTENT(IN)     :: Expected(:,:), Actual(:,:), Tolerance(:,:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[REAL(Single)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize .OR. &
         SIZE(tolerance,dim=1) /= isize .OR. &
         SIZE(tolerance,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- ",&
        &"Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,"); Tolerance:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2), &
        SIZE(tolerance,dim=1), SIZE(tolerance,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL realsp_isequalwithin_scalar( &
          unittest      , &
          expected(i,j) , &
          actual(i,j)   , &
          tolerance(i,j), &
          epsilon_scale = epsilon_scale )
      END DO
    END DO
  END SUBROUTINE realsp_isequalwithin_rank2


  SUBROUTINE realdp_isequalwithin_scalar( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Double),        INTENT(IN)     :: Expected, Actual, Tolerance
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[REAL(Double)]'
    ! Variables
    REAL(Double) :: tol
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Default tolerance
    tol = tolerance
    ! ...Check optional arguments
    IF ( PRESENT(epsilon_scale) ) THEN
      IF ( epsilon_scale ) tol = epsilon(expected) * get_multiplier( expected )
    END IF
    ! ...Assign the test
    test = (abs(expected-actual) < tol)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected:     ",'//rfmt//',a,&
         &7x,"To within:    ",'//rfmt//',a,&
         &7x,"And got:      ",'//rfmt//',a,&
         &7x,"|Difference|: ",'//rfmt//')') &
      crlf, expected, crlf, tol, crlf, actual, crlf, abs(expected-actual)
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE realdp_isequalwithin_scalar


  SUBROUTINE realdp_isequalwithin_rank1(  &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Double),        INTENT(IN)     :: Expected(:), Actual(:), Tolerance(:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[REAL(Double)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual)    /= isize .OR. &
         SIZE(tolerance) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0,"; Tolerance:",i0)') &
        isize, SIZE(actual), SIZE(tolerance)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL realdp_isequalwithin_scalar( &
        unittest    , &
        expected(i) , &
        actual(i)   , &
        tolerance(i), &
        epsilon_scale = epsilon_scale )
    END DO
  END SUBROUTINE realdp_isequalwithin_rank1


  SUBROUTINE realdp_isequalwithin_rank2( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    REAL(Double),        INTENT(IN)     :: Expected(:,:), Actual(:,:), Tolerance(:,:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[REAL(Double)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize .OR. &
         SIZE(tolerance,dim=1) /= isize .OR. &
         SIZE(tolerance,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- ",&
        &"Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,"); Tolerance:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2), &
        SIZE(tolerance,dim=1), SIZE(tolerance,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL realdp_isequalwithin_scalar( &
          unittest      , &
          expected(i,j) , &
          actual(i,j)   , &
          tolerance(i,j), &
          epsilon_scale = epsilon_scale )
      END DO
    END DO
  END SUBROUTINE realdp_isequalwithin_rank2


  SUBROUTINE complexsp_isequalwithin_scalar( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Single),     INTENT(IN)     :: Expected, Actual, Tolerance
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[COMPLEX(Single)]'
    ! Variables
    REAL(Single) :: tolr, toli
    REAL(Single) :: zr, zi
    REAL(Single) :: dzr, dzi
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Split expected into real and imag
    zr = REAL(Expected,Single)
    zi = aimag(expected)
    ! ...Default tolerance
    tolr = REAL(Tolerance,Single)
    toli = aimag(tolerance)
    ! ...Check optional arguments
    IF ( PRESENT(epsilon_scale) ) THEN
      IF ( epsilon_scale ) THEN
        tolr = epsilon(zr) * get_multiplier(zr)
        toli = epsilon(zi) * get_multiplier(zi)
      END IF
    END IF
    ! ...Assign the test
    dzr = abs(zr - REAL(Actual,Single))
    dzi = abs(zi - aimag(actual))
    test = (dzr < tolr) .AND. (dzi < toli)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected:     ",'//zfmt//',a,&
         &7x,"To within:    ",'//zfmt//',a,&
         &7x,"And got:      ",'//zfmt//',a,&
         &7x,"|Difference|: ",'//zfmt//')') &
      crlf, expected, crlf, cmplx(tolr,toli,single), crlf, actual, crlf, dzr, dzi
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE complexsp_isequalwithin_scalar


  SUBROUTINE complexsp_isequalwithin_rank1( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Single),     INTENT(IN)     :: Expected(:), Actual(:), Tolerance(:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[COMPLEX(Single)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual)    /= isize .OR. &
         SIZE(tolerance) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0,"; Tolerance:",i0)') &
        isize, SIZE(actual), SIZE(tolerance)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL complexsp_isequalwithin_scalar( &
        unittest    , &
        expected(i) , &
        actual(i)   , &
        tolerance(i), &
        epsilon_scale = epsilon_scale )
    END DO
  END SUBROUTINE complexsp_isequalwithin_rank1


  SUBROUTINE complexsp_isequalwithin_rank2( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Single),     INTENT(IN)     :: Expected(:,:), Actual(:,:), Tolerance(:,:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[COMPLEX(Single)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize .OR. &
         SIZE(tolerance,dim=1) /= isize .OR. &
         SIZE(tolerance,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- ",&
        &"Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,"); Tolerance:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2), &
        SIZE(tolerance,dim=1), SIZE(tolerance,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL complexsp_isequalwithin_scalar( &
          unittest      , &
          expected(i,j) , &
          actual(i,j)   , &
          tolerance(i,j), &
          epsilon_scale = epsilon_scale )
      END DO
    END DO
  END SUBROUTINE complexsp_isequalwithin_rank2


  SUBROUTINE complexdp_isequalwithin_scalar( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Double),     INTENT(IN)     :: Expected, Actual, Tolerance
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[COMPLEX(Double)]'
    ! Variables
    REAL(Double) :: tolr, toli
    REAL(Double) :: zr, zi
    REAL(Double) :: dzr, dzi
    LOGICAL :: Test
    LOGICAL :: Verbose
    CHARACTER(SL) :: Message

    ! Setup
    ! ...Split expected into real and imag
    zr = REAL(Expected,Double)
    zi = aimag(expected)
    ! ...Default tolerance
    tolr = REAL(Tolerance,Double)
    toli = aimag(tolerance)
    ! ...Check optional arguments
    IF ( PRESENT(epsilon_scale) ) THEN
      IF ( epsilon_scale ) THEN
        tolr = epsilon(zr) * get_multiplier(zr)
        toli = epsilon(zi) * get_multiplier(zi)
      END IF
    END IF
    ! ...Assign the test
    dzr = abs(zr - REAL(Actual,Double))
    dzi = abs(zi - aimag(actual))
    test = (dzr < tolr) .AND. (dzi < toli)
    ! ...Locally modify properties for this test
    CALL get_property( &
      unittest, &
      verbose = verbose )
    verbose = verbose .OR. (.NOT. test)  ! Always output test failure


    ! Assert the test
    IF ( test ) THEN
      CALL test_passed( unittest )
    ELSE
      CALL test_failed( unittest )
    END IF

    ! Output message
    WRITE( message, &
      '(a,7x,"Expected:     ",'//zfmt//',a,&
         &7x,"To within:    ",'//zfmt//',a,&
         &7x,"And got:      ",'//zfmt//',a,&
         &7x,"|Difference|: ",'//zfmt//')') &
      crlf, expected, crlf, cmplx(tolr,toli,double), crlf, actual, crlf, dzr, dzi
    CALL set_property( &
      unittest, &
      level = test_level, &
      Procedure = procedure_name, &
      message = message )
    IF ( verbose ) CALL display_message( unittest )
  END SUBROUTINE complexdp_isequalwithin_scalar


  SUBROUTINE complexdp_isequalwithin_rank1( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Double),     INTENT(IN)     :: Expected(:), Actual(:), Tolerance(:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[COMPLEX(Double)]'
    ! Variables
    INTEGER :: i, isize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected)
    IF ( SIZE(actual)    /= isize .OR. &
         SIZE(tolerance) /= isize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- Expected:",i0,"; Actual:",i0,"; Tolerance:",i0)') &
        isize, SIZE(actual), SIZE(tolerance)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO i = 1, isize
      CALL complexdp_isequalwithin_scalar( &
        unittest    , &
        expected(i) , &
        actual(i)   , &
        tolerance(i), &
        epsilon_scale = epsilon_scale )
    END DO
  END SUBROUTINE complexdp_isequalwithin_rank1


  SUBROUTINE complexdp_isequalwithin_rank2( &
    UnitTest     , &
    Expected     , &
    Actual       , &
    Tolerance    , &
    Epsilon_Scale  )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    COMPLEX(Double),     INTENT(IN)     :: Expected(:,:), Actual(:,:), Tolerance(:,:)
    LOGICAL,   OPTIONAL, INTENT(IN)     :: Epsilon_Scale
    ! Parameters
    CHARACTER(*), PARAMETER :: PROCEDURE_NAME = 'UnitTest_IsEqualWithin[COMPLEX(Double)]'
    ! Variables
    INTEGER :: i, j, isize, jsize
    CHARACTER(SL) :: Message

    ! Check array sizes
    isize = SIZE(expected,dim=1); jsize = SIZE(expected,dim=2)
    IF ( SIZE(actual,dim=1) /= isize .OR. &
         SIZE(actual,dim=2) /= jsize .OR. &
         SIZE(tolerance,dim=1) /= isize .OR. &
         SIZE(tolerance,dim=2) /= jsize ) THEN
      CALL test_failed( unittest )
      WRITE( message, &
        '("Array sizes are diffferent -- ",&
        &"Expected:(",i0,",",i0,"); Actual:(",i0,",",i0,"); Tolerance:(",i0,",",i0,")")') &
        isize, jsize, &
        SIZE(actual,dim=1), SIZE(actual,dim=2), &
        SIZE(tolerance,dim=1), SIZE(tolerance,dim=2)
      CALL set_property( &
        unittest, &
        level = test_level, &
        Procedure = procedure_name, &
        message = message )
      CALL display_message( unittest )
      RETURN
    ENDIF

    ! Loop over elements
    DO j = 1, jsize
      DO i = 1, isize
        CALL complexdp_isequalwithin_scalar( &
          unittest      , &
          expected(i,j) , &
          actual(i,j)   , &
          tolerance(i,j), &
          epsilon_scale = epsilon_scale )
      END DO
    END DO
  END SUBROUTINE complexdp_isequalwithin_rank2


!--------------------------------------------------------------------------------
!:sdoc+:
!
! NAME:
!       UnitTest_DefineVersion
!
! PURPOSE:
!       Subroutine to return the module version information.
!
! CALLING SEQUENCE:
!       CALL UnitTest_DefineVersion( Id )
!
! OUTPUTS:
!       Id:    Character string containing the version Id information
!              for the module.
!              UNITS:      N/A
!              TYPE:       CHARACTER(*)
!              DIMENSION:  Scalar
!              ATTRIBUTES: INTENT(OUT)
!
!:sdoc-:
!--------------------------------------------------------------------------------

  SUBROUTINE unittest_defineversion( Id )
    CHARACTER(*), INTENT(OUT) :: id
    id = module_version_id
  END SUBROUTINE unittest_defineversion


!################################################################################
!################################################################################
!##                                                                            ##
!##                        ## PRIVATE MODULE ROUTINES ##                       ##
!##                                                                            ##
!################################################################################
!################################################################################

!===================
! METHOD PROCEDURES
!===================

!------------------------------------------------------------------------------
!
! NAME:
!       Set_Property
!
! PURPOSE:
!       Private subroutine to set the properties of a UnitTest object.
!
!       All WRITE access to the UnitTest object properties should be
!       done using this subroutine.
!
! CALLING SEQUENCE:
!       CALL Set_Property( &
!         UnitTest, &
!         Verbose           = Verbose          , &
!         Title             = Title            , &
!         Caller            = Caller           , &
!         Level             = Level            , &
!         Procedure         = Procedure        , &
!         Message           = Message          , &
!         Test_Result       = Test_Result      , &
!         n_Tests           = n_Tests          , &
!         n_Passed_Tests    = n_Passed_Tests   , &
!         n_Failed_Tests    = n_Failed_Tests   , &
!         n_AllTests        = n_AllTests       , &
!         n_Passed_AllTests = n_Passed_AllTests, &
!         n_Failed_AllTests = n_Failed_AllTests  )
!
! OBJECT:
!       UnitTest:           UnitTest object.
!                           UNITS:      N/A
!                           TYPE:       TYPE(UnitTest_type)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN OUT)
!
! OPTIONAL INPUTS:
!       Verbose:            Logical to control length of reporting output.
!                           If == .FALSE., Only failed tests are reported.
!                              == .TRUE.,  Both failed and passed tests are reported.
!                           UNITS:      N/A
!                           TYPE:       LOGICAL
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Title:              Character string containing the title of the
!                           test to be performed.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Caller:             Character string containing the name of the
!                           calling subprogram.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Level:              Integer flag specifying the output message level.
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Procedure:          The name of the UnitTest procedure.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Message:            Character string containing an informational
!                           message about the unit test performed.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Test_Result:        Logical to contain the result of unit tests
!                           performed
!                           If == .TRUE.,  Test passed.
!                              == .FALSE., Test failed.
!                           UNITS:      N/A
!                           TYPE:       LOGICAL
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       n_Tests:            The number of tests performed for the current
!                           unit test type, i.e. since the last call to
!                           UnitTest_Setup().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       n_Passed_Tests:     The number of tests passed for the current
!                           unit test type, i.e. since the last call to
!                           UnitTest_Setup().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       n_Failed_Tests:     The number of tests failed for the current
!                           unit test type, i.e. since the last call to
!                           UnitTest_Setup().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       n_AllTests:         The total number of tests performed, i.e. since
!                           the last call to UnitTest_Init().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       n_Passed_AllTests:  The total number of tests passed, i.e. since
!                           the last call to UnitTest_Init().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       n_Failed_AllTests:  The total number of tests failed, i.e. since
!                           the last call to UnitTest_Init().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!------------------------------------------------------------------------------

  PURE SUBROUTINE set_property( &
    UnitTest         , & ! Object
    Verbose          , & ! Optional input
    Title            , & ! Optional input
    Caller           , & ! Optional input
    Level            , & ! Optional input
    Procedure        , & ! Optional input
    Message          , & ! Optional input
    Test_Result      , & ! Optional input
    n_Tests          , & ! Optional input
    n_Passed_Tests   , & ! Optional input
    n_Failed_Tests   , & ! Optional input
    n_AllTests       , & ! Optional input
    n_Passed_AllTests, & ! Optional input
    n_Failed_AllTests  ) ! Optional input
    ! Arguments
    TYPE(unittest_type)   , INTENT(IN OUT) :: unittest
    LOGICAL     , OPTIONAL, INTENT(IN)     :: verbose
    CHARACTER(*), OPTIONAL, INTENT(IN)     :: title
    CHARACTER(*), OPTIONAL, INTENT(IN)     :: caller
    INTEGER     , OPTIONAL, INTENT(IN)     :: level
    CHARACTER(*), OPTIONAL, INTENT(IN)     :: procedure
    CHARACTER(*), OPTIONAL, INTENT(IN)     :: message
    LOGICAL     , OPTIONAL, INTENT(IN)     :: test_result
    INTEGER     , OPTIONAL, INTENT(IN)     :: n_tests
    INTEGER     , OPTIONAL, INTENT(IN)     :: n_passed_tests
    INTEGER     , OPTIONAL, INTENT(IN)     :: n_failed_tests
    INTEGER     , OPTIONAL, INTENT(IN)     :: n_alltests
    INTEGER     , OPTIONAL, INTENT(IN)     :: n_passed_alltests
    INTEGER     , OPTIONAL, INTENT(IN)     :: n_failed_alltests
    ! Set the object properties
    IF ( PRESENT(verbose          ) ) unittest%Verbose           = verbose
    IF ( PRESENT(title            ) ) unittest%Title             = title
    IF ( PRESENT(caller           ) ) unittest%Caller            = caller
    IF ( PRESENT(level            ) ) unittest%Level             = level
    IF ( PRESENT(Procedure        ) ) unittest%Procedure         = procedure
    IF ( PRESENT(message          ) ) unittest%Message           = message
    IF ( PRESENT(test_result      ) ) unittest%Test_Result       = test_result
    IF ( PRESENT(n_tests          ) ) unittest%n_Tests           = n_tests
    IF ( PRESENT(n_passed_tests   ) ) unittest%n_Passed_Tests    = n_passed_tests
    IF ( PRESENT(n_failed_tests   ) ) unittest%n_Failed_Tests    = n_failed_tests
    IF ( PRESENT(n_alltests       ) ) unittest%n_AllTests        = n_alltests
    IF ( PRESENT(n_passed_alltests) ) unittest%n_Passed_AllTests = n_passed_alltests
    IF ( PRESENT(n_failed_alltests) ) unittest%n_Failed_AllTests = n_failed_alltests
  END SUBROUTINE set_property


!------------------------------------------------------------------------------
!
! NAME:
!       Get_Property
!
! PURPOSE:
!       Private subroutine to get the properties of a UnitTest object.
!
!       All READ access to the UnitTest object properties should be
!       done using this subroutine.
!
! CALLING SEQUENCE:
!       CALL Get_Property( &
!         UnitTest, &
!         Verbose           = Verbose          , &
!         Title             = Title            , &
!         Caller            = Caller           , &
!         Level             = Level            , &
!         Procedure         = Procedure        , &
!         Message           = Message          , &
!         Test_Result       = Test_Result      , &
!         n_Tests           = n_Tests          , &
!         n_Passed_Tests    = n_Passed_Tests   , &
!         n_Failed_Tests    = n_Failed_Tests   , &
!         n_AllTests        = n_AllTests       , &
!         n_Passed_AllTests = n_Passed_AllTests, &
!         n_Failed_AllTests = n_Failed_AllTests  )
!
! OBJECT:
!       UnitTest:           UnitTest object.
!                           UNITS:      N/A
!                           TYPE:       TYPE(UnitTest_type)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN)
!
! OPTIONAL OUTPUTS:
!       Verbose:            Logical to control length of reporting output.
!                           If == .FALSE., Only failed tests are reported.
!                              == .TRUE.,  Both failed and passed tests are reported.
!                           UNITS:      N/A
!                           TYPE:       LOGICAL
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Title:              Character string containing the title of the
!                           test to be performed.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Caller:             Character string containing the name of the
!                           calling subprogram.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Level:              Integer flag specifying the output message level.
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Procedure:          The name of the last UnitTest Procedure called.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(IN), OPTIONAL
!
!       Message:            Character string containing an informational
!                           message about the last unit test performed.
!                           UNITS:      N/A
!                           TYPE:       CHARACTER(*)
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       Test_Result:        Logical containing the result of the last
!                           unit test performed
!                           If == .TRUE.,  Test passed.
!                              == .FALSE., Test failed.
!                           UNITS:      N/A
!                           TYPE:       LOGICAL
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Tests:            The number of tests performed for the current
!                           unit test type, i.e. since the last call to
!                           UnitTest_Setup().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Passed_Tests:     The number of tests passed for the current
!                           unit test type, i.e. since the last call to
!                           UnitTest_Setup().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Failed_Tests:     The number of tests failed for the current
!                           unit test type, i.e. since the last call to
!                           UnitTest_Setup().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_AllTests:         The total number of tests performed, i.e. since
!                           the last call to UnitTest_Init().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Passed_AllTests:  The total number of tests passed, i.e. since
!                           the last call to UnitTest_Init().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!       n_Failed_AllTests:  The total number of tests failed, i.e. since
!                           the last call to UnitTest_Init().
!                           UNITS:      N/A
!                           TYPE:       INTEGER
!                           DIMENSION:  Scalar
!                           ATTRIBUTES: INTENT(OUT), OPTIONAL
!
!------------------------------------------------------------------------------

  PURE SUBROUTINE get_property( &
    UnitTest         , & ! Object
    Verbose          , & ! Optional output
    Title            , & ! Optional output
    Caller           , & ! Optional output
    Level            , & ! Optional output
    Procedure        , & ! Optional output
    Message          , & ! Optional output
    Test_Result      , & ! Optional output
    n_Tests          , & ! Optional output
    n_Passed_Tests   , & ! Optional output
    n_Failed_Tests   , & ! Optional output
    n_AllTests       , & ! Optional output
    n_Passed_AllTests, & ! Optional output
    n_Failed_AllTests  ) ! Optional output
    ! Arguments
    TYPE(unittest_type)   , INTENT(IN)  :: unittest
    LOGICAL     , OPTIONAL, INTENT(OUT) :: verbose
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: title
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: caller
    INTEGER     , OPTIONAL, INTENT(OUT) :: level
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: procedure
    CHARACTER(*), OPTIONAL, INTENT(OUT) :: message
    LOGICAL     , OPTIONAL, INTENT(OUT) :: test_result
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_tests
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_passed_tests
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_failed_tests
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_alltests
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_passed_alltests
    INTEGER     , OPTIONAL, INTENT(OUT) :: n_failed_alltests
    ! Get the object properties
    IF ( PRESENT(verbose          ) ) verbose           = unittest%Verbose
    IF ( PRESENT(title            ) ) title             = unittest%Title
    IF ( PRESENT(caller           ) ) caller            = unittest%Caller
    IF ( PRESENT(level            ) ) level             = unittest%Level
    IF ( PRESENT(Procedure        ) ) Procedure         = unittest%Procedure
    IF ( PRESENT(message          ) ) message           = unittest%Message
    IF ( PRESENT(test_result      ) ) test_result       = unittest%Test_Result
    IF ( PRESENT(n_tests          ) ) n_tests           = unittest%n_Tests
    IF ( PRESENT(n_passed_tests   ) ) n_passed_tests    = unittest%n_Passed_Tests
    IF ( PRESENT(n_failed_tests   ) ) n_failed_tests    = unittest%n_Failed_Tests
    IF ( PRESENT(n_alltests       ) ) n_alltests        = unittest%n_AllTests
    IF ( PRESENT(n_passed_alltests) ) n_passed_alltests = unittest%n_Passed_AllTests
    IF ( PRESENT(n_failed_alltests) ) n_failed_alltests = unittest%n_Failed_AllTests
  END SUBROUTINE get_property


!------------------------------------------------------------------------------
!
! NAME:
!       Test_Passed
!
! PURPOSE:
!       Subroutine to increment passed test counters.
!
! CALLING SEQUENCE:
!       CALL Test_Passed( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
!------------------------------------------------------------------------------

  SUBROUTINE test_passed( UnitTest )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    ! Variables
    INTEGER :: n_Passed_Tests, n_Passed_AllTests

    ! Increment total test counters
    CALL test_increment( unittest )

    ! Increment the passed test counters
    ! ...Get 'em
    CALL get_property( &
      unittest, &
      n_passed_tests = n_passed_tests, &
      n_passed_alltests = n_passed_alltests )
    ! ...Increment
    n_passed_tests    = n_passed_tests    + 1
    n_passed_alltests = n_passed_alltests + 1
    ! ...Save 'em and set successful test result
    CALL set_property( &
      unittest, &
      test_result = .true., &
      n_passed_tests = n_passed_tests, &
      n_passed_alltests = n_passed_alltests )
  END SUBROUTINE test_passed


!------------------------------------------------------------------------------
!
! NAME:
!       Test_Failed
!
! PURPOSE:
!       Subroutine to increment failed test counters.
!
! CALLING SEQUENCE:
!       CALL Test_Failed( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
!------------------------------------------------------------------------------

  SUBROUTINE test_failed( UnitTest )
    ! Arguments
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    ! Variables
    INTEGER :: n_Failed_Tests, n_Failed_AllTests

    ! Increment total test counters
    CALL test_increment( unittest )

    ! Increment the failed test counters
    ! ...Get 'em
    CALL get_property( &
      unittest, &
      n_failed_tests = n_failed_tests, &
      n_failed_alltests = n_failed_alltests )
    ! ...Increment
    n_failed_tests    = n_failed_tests    + 1
    n_failed_alltests = n_failed_alltests + 1
    ! ...Save 'em and set unsuccessful test result
    CALL set_property( &
      unittest, &
      test_result = .false., &
      n_failed_tests = n_failed_tests, &
      n_failed_alltests = n_failed_alltests )
  END SUBROUTINE test_failed


!------------------------------------------------------------------------------
!
! NAME:
!       Test_Increment
!
! PURPOSE:
!       Subroutine to increment the test total counters.
!
! CALLING SEQUENCE:
!       CALL Test_Increment( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
!------------------------------------------------------------------------------

  SUBROUTINE test_increment( UnitTest )
    TYPE(UnitTest_type), INTENT(IN OUT) :: UnitTest
    INTEGER :: n_Tests, n_AllTests

    CALL get_property( &
      unittest, &
      n_tests    = n_tests, &
      n_alltests = n_alltests )

    n_tests    = n_tests    + 1
    n_alltests = n_alltests + 1

    CALL set_property( &
      unittest, &
      n_tests    = n_tests, &
      n_alltests = n_alltests )
  END SUBROUTINE test_increment


!------------------------------------------------------------------------------
!
! NAME:
!       Display_Message
!
! PURPOSE:
!       Subroutine to display the unit test messages to stdout.
!
! CALLING SEQUENCE:
!       CALL Display_Message( UnitTest )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN OUT)
!
!------------------------------------------------------------------------------

  SUBROUTINE display_message( UnitTest )
    TYPE(UnitTest_type), INTENT(IN) :: UnitTest
    ! Variables
    INTEGER :: Level
    CHARACTER(SL) :: Procedure
    CHARACTER(SL) :: Message
    CHARACTER(SL) :: Fmt
    CHARACTER(SL) :: Prefix
    CHARACTER(SL) :: Test_Info
    INTEGER :: n_Spaces

    CALL get_property( &
      unittest, &
      level = level, &
      Procedure = procedure, &
      message = message )

    ! Set output bits manually
    test_info = ''
    SELECT CASE(level)
      CASE(init_level)
        prefix = '/'
        n_spaces = 1
      CASE(setup_level)
        prefix = '/,3x,14("-"),/'
        n_spaces = 3
      CASE(test_level)
        prefix = ''
        n_spaces = 5
        CALL test_info_string( unittest, test_info )
      CASE(report_level)
        prefix = ''
        n_spaces = 3
      CASE(summary_level)
        prefix = '/,1x,16("="),/'
        n_spaces = 1
      CASE DEFAULT
        level = internal_fail_level
        prefix = '/,"INVALID MESSAGE LEVEL!!",/'
        n_spaces = 15
    END SELECT

    ! Write the message to stdout
    WRITE(fmt, '("(",a,i0,"x,""("",a,"") "",a,"": "",a,1x,a)")') trim(prefix), n_spaces
    WRITE( *,fmt=fmt ) trim(message_level(level)), trim(procedure), trim(test_info), trim(message)

  END SUBROUTINE display_message


!------------------------------------------------------------------------------
!
! NAME:
!       Test_Info_String
!
! PURPOSE:
!       Subroutine to construct an info string for message output.
!
! CALLING SEQUENCE:
!       CALL Test_Info_String( UnitTest, info )
!
! OBJECT:
!       UnitTest:      UnitTest object.
!                      UNITS:      N/A
!                      TYPE:       TYPE(UnitTest_type)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(IN)
!
! OUTPUTS:
!       info:          Character string containing the test number and
!                      whether the test passed or failed.
!                      UNITS:      N/A
!                      TYPE:       CHARACTER(*)
!                      DIMENSION:  Scalar
!                      ATTRIBUTES: INTENT(OUT)
!
!------------------------------------------------------------------------------

  SUBROUTINE test_info_string( UnitTest, info )
    TYPE(UnitTest_Type), INTENT(IN) :: UnitTest
    CHARACTER(*), INTENT(OUT) :: info
    INTEGER :: n_Tests
    CHARACTER(6) :: PassFail
    CALL get_property( unittest, n_tests = n_tests )
    IF ( unittest_passed( unittest ) ) THEN
      passfail = 'PASSED'
    ELSE
      passfail = 'FAILED'
    END IF
    WRITE( info,'("Test#",i0,1x,a,".")') n_tests, passfail
  END SUBROUTINE test_info_string


!====================
! UTILITY PROCEDURES
!====================

!------------------------------------------------------------------------------
!
! NAME:
!       Get_Multiplier
!
! PURPOSE:
!       Elemental function to compute the exponent multiplier of an input
!       for use in scaling tolerance values for floating point comparisons.
!
! CALLING SEQUENCE:
!       e = Get_Multiplier(x)
!
! INPUTS:
!       x:             Number for which the exponent multiplier is required.
!                      UNITS:      N/A
!                      TYPE:       REAL(Single)   , or
!                                  REAL(Double)
!                      DIMENSION:  Scalar or any rank
!                      ATTRIBUTES: INTENT(IN)
!
! FUNCTION RESULT:
!       e:             Exponent multiplier to use in scaling tolerance values.
!                      UNITS:      N/A
!                      TYPE:       Same as input x.
!                      DIMENSION:  Same as input x.
!
!------------------------------------------------------------------------------

  ELEMENTAL FUNCTION realsp_get_multiplier(x) RESULT(e)
    REAL(Single), INTENT(IN) :: x
    REAL(Single) :: e
    IF (x > 0.0_single) THEN
      e = 10.0_single**floor(log10(x))
    ELSE
      e = 1.0_single
    END IF
  END FUNCTION realsp_get_multiplier

  ELEMENTAL FUNCTION realdp_get_multiplier(x) RESULT(e)
    REAL(Double), INTENT(IN) :: x
    REAL(Double) :: e
    IF (x > 0.0_double) THEN
      e = 10.0_double**floor(log10(x))
    ELSE
      e = 1.0_double
    END IF
  END FUNCTION realdp_get_multiplier

END MODULE unittest_define