feat: add test-oracle & command-line abstractions

Author: Damian Rouson

src/command_line_implementation.f90

@@ -0,0 +1,37 @@
+submodule(command_line_interface) command_line_implementation
+  implicit none
+
+contains
+
+  module procedure argument_present
+      !! list of acceptable arguments
+      !! sample list: [character(len=len(longest_argument)):: "--benchmark", "-b", "/benchmark", "/b"]
+      !! where dashes support Linux/macOS and slashes support Windows
+    integer :: i, argnum, arglen
+      !! loop counter, argument position, argument length
+    character(len=32) arg
+      !! argument position
+
+      !! acceptable argument lengths (used to preclude extraneous trailing characters)
+
+    associate(acceptable_length => [(len(trim(acceptable_argument(i))), i = 1, size(acceptable_argument))])
+
+      found = .false.
+
+      do argnum = 1,command_argument_count()
+
+        call get_command_argument(argnum, arg, arglen)
+
+        if (any( &
+          [(arg==acceptable_argument(i) .and. arglen==acceptable_length(i), i = 1, size(acceptable_argument))] &
+        )) then
+          found = .true.
+        end if
+
+      end do
+
+    end associate
+
+  end procedure
+
+end submodule

src/command_line_interface.f90

@@ -0,0 +1,26 @@
+module command_line_interface
+  !! return command line argument information
+  implicit none
+
+  private
+  public :: command_line_t
+
+  type command_line_t
+  contains
+    procedure, nopass :: argument_present
+  end type
+
+  interface
+
+    module function argument_present(acceptable_argument) result(found)
+      !! result is .true. only if a command-line argument matches an element of this function's argument
+      character(len=*), intent(in) :: acceptable_argument(:)
+        !! sample list: [character(len=len(<longest_argument>)):: "--benchmark", "-b", "/benchmark", "/b"]
+        !! where dashes support Linux/macOS, slashes support Windows, and <longest_argument> must be replaced
+        !! by the longest list element ("--benchmark" above)
+      logical found
+    end function
+
+  end interface
+
+end module

src/oracle_implementation.f90

@@ -0,0 +1,15 @@
+submodule(oracle_interface) oracle_implementation
+  !! define procedures corresponding to the interface bodies in oracle_interface
+  implicit none
+
+contains
+
+  module procedure within_tolerance
+    class(oracle), allocatable :: error
+
+    error = this - reference
+    in_tolerance = (error%norm() <= tolerance)
+
+  end procedure
+
+end submodule oracle_implementation

src/oracle_interface.f90

@@ -0,0 +1,52 @@
+module oracle_interface
+  !! verify actual output against expected
+  use object_interface, only : object
+  implicit none
+
+  private
+  public :: oracle
+
+  type, abstract, extends(object) :: oracle
+    !! define procedures for testing output values against expected values
+  contains
+    procedure(subtract_interface), deferred :: subtract
+    procedure(norm_interface), deferred :: norm
+    generic :: operator(-) => subtract
+    procedure :: within_tolerance
+  end type
+
+  abstract interface
+
+    function subtract_interface(this, rhs) result(difference)
+      !! result has components corresponding to subtracting rhs's components fron this object's components
+      import oracle
+      implicit none
+      class(oracle), intent(in) :: this, rhs
+      class(oracle), allocatable :: difference
+    end function
+
+    pure function norm_interface(this) result(norm_of_this)
+      !! result is a norm of the array formed by concatenating the real components of this object
+      import oracle
+      implicit none
+      class(oracle), intent(in) :: this
+      real norm_of_this
+    end function
+
+  end interface
+
+  interface
+
+    module function within_tolerance(this, reference, tolerance) result(in_tolerance)
+      !! template method with true result iff the difference in state vectors (this - reference) has a norm within tolerance
+      !! (impure because of internal call to 'subtract' binding)
+      !! The existence of this procedure eliminates the need to rewrite similar code for every oracle child type.
+      implicit none
+      class(oracle), intent(in) :: this, reference
+      real, intent(in) :: tolerance
+      logical in_tolerance
+    end function
+
+  end interface
+
+end module