Direct comparison for tests.

Author: MilanSkocic

test/constants/test_constants.f90

@@ -18,7 +18,6 @@ module test_constants
                              STANDARD_ACCELERATION_OF_GRAVITY
     implicit none
     private
-    real(dp) :: fac
     public :: collect_constants
 
 contains
@@ -58,299 +57,163 @@ subroutine collect_constants(testsuite)
 
 subroutine test_year(error)
     type(error_type), allocatable, intent(out) :: error
-
-    integer(int32) :: value, expected, diff
-
-    expected = 2022
-    value = YEAR
-    diff = expected - value
-    call check(error, diff, 0)
+    call check(error, 2022 - YEAR, 0)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_ALPHA_PARTICLE_ELECTRON_MASS_RATIO(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 7294.29954171d0 * fac
-    value = ALPHA_PARTICLE_ELECTRON_MASS_RATIO%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 7294.29954171_dp - ALPHA_PARTICLE_ELECTRON_MASS_RATIO%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_ALPHA_PARTICLE_MASS(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d27
-    expected = 6.6446573450d-27 * fac
-    value = ALPHA_PARTICLE_MASS%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 6.6446573450d-27 - ALPHA_PARTICLE_MASS%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_ATOMIC_MASS_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d27
-    expected = 1.66053906892d-27 * fac
-    value = ATOMIC_MASS_CONSTANT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 1.66053906892d-27 - ATOMIC_MASS_CONSTANT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_AVOGADRO_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d-23
-    expected =  6.02214076d23 * fac
-    value = AVOGADRO_CONSTANT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 6.02214076d23 - AVOGADRO_CONSTANT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_BOLTZMANN_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d23
-    expected =  1.380649d-23 * fac
-    value = BOLTZMANN_CONSTANT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 1.380649d-23 - BOLTZMANN_CONSTANT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_ELECTRON_VOLT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d19
-    expected = 1.602176634d-19 * fac
-    value = ELECTRON_VOLT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 1.602176634d-19 - ELECTRON_VOLT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_ELEMENTARY_CHARGE(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d19
-    expected = 1.602176634d-19 * fac
-    value = ELEMENTARY_CHARGE%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 1.602176634d-19 - ELEMENTARY_CHARGE%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_FARADAY_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 96485.33212d0 * fac
-    value = FARADAY_CONSTANT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 96485.33212d0 - FARADAY_CONSTANT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_MOLAR_MASS_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d3
-    expected = 1.00000000105d-3 * fac
-    value = MOLAR_MASS_CONSTANT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 1.00000000105d-3 - MOLAR_MASS_CONSTANT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_MOLAR_VOLUME_NTP(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d3
-    expected = 22.41396954d-3 * fac
-    value = MOLAR_VOLUME_OF_IDEAL_GAS_273_15_K_101_325_KPA%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 22.41396954d-3 - MOLAR_VOLUME_OF_IDEAL_GAS_273_15_K_101_325_KPA%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_PLANCK_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d34
-    expected = 6.62607015d-34 * fac
-    value = PLANCK_CONSTANT%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 6.62607015d-34 - PLANCK_CONSTANT%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_SPEED_OF_LIGHT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 299792458.0d0 * fac
-    value = SPEED_OF_LIGHT_IN_VACUUM%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 299792458.0d0 - SPEED_OF_LIGHT_IN_VACUUM%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_STANDARD_ACCELERATION_OF_GRAVITY(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 9.80665d0 * fac
-    value = STANDARD_ACCELERATION_OF_GRAVITY%to_real(fac) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 9.80665d0 - STANDARD_ACCELERATION_OF_GRAVITY%to_real(1.0_dp), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_ALPHA_PARTICLE_ELECTRON_MASS_RATIO(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d7
-    expected = 0.00000017d0 * fac
-    value = ALPHA_PARTICLE_ELECTRON_MASS_RATIO%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 0.00000017d0 - ALPHA_PARTICLE_ELECTRON_MASS_RATIO%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_ALPHA_PARTICLE_MASS(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d36
-    expected = 0.0000000021d-27 * fac
-    value = ALPHA_PARTICLE_MASS%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 0.0000000021d-27 - ALPHA_PARTICLE_MASS%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_ATOMIC_MASS_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d37
-    expected = 0.00000000052d-27 * fac
-    value = ATOMIC_MASS_CONSTANT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 0.00000000052d-27 - ATOMIC_MASS_CONSTANT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_AVOGADRO_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = AVOGADRO_CONSTANT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, AVOGADRO_CONSTANT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_BOLTZMANN_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = BOLTZMANN_CONSTANT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, BOLTZMANN_CONSTANT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_ELECTRON_VOLT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = ELECTRON_VOLT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, ELECTRON_VOLT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_ELEMENTARY_CHARGE(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = ELEMENTARY_CHARGE%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, ELEMENTARY_CHARGE%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_FARADAY_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = FARADAY_CONSTANT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, FARADAY_CONSTANT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_MOLAR_MASS_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d13
-    expected = 0.00000000031d-3 * fac
-    value = MOLAR_MASS_CONSTANT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, 0.00000000031d-3 - MOLAR_MASS_CONSTANT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_MOLAR_VOLUME_NTP(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = MOLAR_VOLUME_OF_IDEAL_GAS_273_15_K_101_325_KPA%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, MOLAR_VOLUME_OF_IDEAL_GAS_273_15_K_101_325_KPA%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_PLANCK_CONSTANT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = PLANCK_CONSTANT%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, PLANCK_CONSTANT%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_SPEED_OF_LIGHT(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = SPEED_OF_LIGHT_IN_VACUUM%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, SPEED_OF_LIGHT_IN_VACUUM%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine
 
 subroutine test_U_STANDARD_ACCELERATION_OF_GRAVITY(error)
     type(error_type), allocatable, intent(out) :: error
-    real(dp) :: value, expected, diff
-    fac = 1.0d0
-    expected = 0.0d0 * fac
-    value = STANDARD_ACCELERATION_OF_GRAVITY%to_real(fac, uncertainty=.true.) * fac
-    diff = expected - value
-    call check(error, diff, 0.0d0)
+    call check(error, STANDARD_ACCELERATION_OF_GRAVITY%to_real(1.0_dp, uncertainty=.true.), 0.0_dp)
     if (allocated(error)) return
 end subroutine