feat: rm format strings test from test/main

Author: rouson

src/test_result_s.f90

@@ -9,7 +9,7 @@
     end procedure
 
     module procedure characterize
-      characterization = merge("Passes on ", "Fails on  ", self%passed_) // self%description_ // "."
+      characterization = merge("passes on ", "fails on  ", self%passed_) // self%description_ // "."
     end procedure
 
 end submodule test_result_s

tests/formats_test.f90

@@ -1,80 +1,71 @@
 module formats_test
+  !! Verify that format strings provide the desired formatting
+  use formats_m, only : separated_values
+  use test_m, only : test_t, test_result_t
+  implicit none
 
-   !! author: Damian Rouson
-   !!
-   !! summary: verify that format strings provide the desired formatting
-   use vegetables, only: &
-     result_t, test_item_t, &   ! types
-     describe, it, assert_equals ! functions
-   use formats_m, only : separated_values
-   implicit none
+  private
+  public :: formats_test_t
 
-   private
-   public :: test_object
+  type, extends(test_t) :: formats_test_t
+  contains
+    procedure, nopass :: subject
+    procedure, nopass :: results
+  end type
 
 contains
 
-  function test_object() result(tests)
-    type(test_item_t) tests
+  pure function subject() result(specimen)
+    character(len=:), allocatable :: specimen
+    specimen = "The csv format" 
+  end function
+
+  pure function results() result(test_results)
+    type(test_result_t), allocatable :: test_results(:)
 
-    tests = describe( &
-     "csv format", &
-     [it( &
-       "yields a comma-separated list of real numbers", &
-       check_csv_reals), &
-      it( &
-       "yields a space-separated list of complex numbers", &
-       check_space_separated_complex), &
-      it( &
-       "yields a comma- and space-separated list of character values", &
-       check_cssv_character), &
-      it( &
-       "yields a new-line-separated list of integer numbers", &
-       check_new_line_separated_integers)])
+    test_results = [ &
+      test_result_t("yielding a comma-separated list of real numbers", check_csv_reals()), &
+      test_result_t("yielding a space-separated list of complex numbers", check_space_separated_complex()), &
+      test_result_t("yielding a comma- and space-separated list of character values", check_csv_character()), &
+      test_result_t("yielding a new-line-separated list of integer numbers", check_new_line_separated_integers()) &
+    ]
   end function
 
-  function check_csv_reals() result(result_)
-    type(result_t) result_
+  pure function check_csv_reals() result(test_passes)
+    logical test_passes
     character(len=*), parameter :: expected_output =  "0.00000000,1.00000000,2.00000000"
     character(len=len(expected_output)) captured_output 
 
     write(captured_output, fmt = separated_values(separator=",", mold=[integer::])) [0.,1.,2.]
-
-    result_ = assert_equals(expected_output, captured_output)
+    test_passes = expected_output == captured_output
   end function
 
-  function check_space_separated_complex() result(result_)
-    type(result_t) result_
-
+  pure function check_space_separated_complex() result(test_passes)
+    logical test_passes 
     character(len=*), parameter :: expected_output = "(0.00000000,1.00000000) (1.00000000,0.00000000)"
     character(len=len(expected_output)) captured_output 
 
     write(captured_output, fmt = separated_values(separator=" ", mold=[complex::])) [(0.,1.),(1.,0.)]
-
-    result_ = assert_equals(expected_output, captured_output)
+    test_passes = expected_output == captured_output
   end function
 
-  function check_new_line_separated_integers() result(result_)
-    type(result_t) result_
-
+  pure function check_new_line_separated_integers() result(test_passes)
+    logical test_passes
     character(len=*), parameter :: expected_output = ( "0" // new_line("") // "1" //new_line("") // "2")
     character(len=len(expected_output)) captured_output 
 
     write(captured_output, fmt = separated_values(separator=new_line(""), mold=[integer::])) [0,1,2]
-
-    result_ = assert_equals(captured_output, "0" // new_line("") // "1" //new_line("") // "2")
+    test_passes = captured_output == "0" // new_line("") // "1" //new_line("") // "2"
   end function
 
-  function check_cssv_character() result(result_)
-    type(result_t) result_
-
+  pure function check_csv_character() result(test_passes)
+    logical test_passes
     integer, parameter :: num_spaces=3
     character(len=*), parameter :: expected_output = "Yodel, Ay, Hee, Hoo!"
     character(len=len(expected_output)+num_spaces) captured_output 
 
     write(captured_output, fmt = separated_values(separator=", ", mold=[integer::])) "Yodel", "Ay", "Hee", "Hoo!"
-
-    result_ = assert_equals(expected_output, captured_output)
+    test_passes= expected_output == captured_output
   end function
 
 end module formats_test

tests/main.f90

@@ -8,18 +8,14 @@ subroutine run()
         use data_partition_test, only: &
                 data_partition_data_partition => &
                     test_data_partition
-        use formats_test, only: &
-                formats_object => &
-                    test_object
         use vegetables, only: test_item_t, test_that, run_tests
 
 
 
         type(test_item_t) :: tests
-        type(test_item_t) :: individual_tests(2)
+        type(test_item_t) :: individual_tests(1)
 
         individual_tests(1) = data_partition_data_partition()
-        individual_tests(2) = formats_object()
         tests = test_that(individual_tests)
 
 

tests/test-driver.f90

@@ -1,11 +1,14 @@
 program main
   use user_defined_collectives_test, only : collectives_test_t  
   use object_m_test, only : object_test_t  
+  use formats_test, only : formats_test_t  
   implicit none
 
   type(collectives_test_t) collectives_test
   type(object_test_t) object_test
+  type(formats_test_t) formats_test
 
   call collectives_test%report()
   call object_test%report()
+  call formats_test%report()
 end program