feat: rm user_defined_collectives from test/main

This is the first step in replacing the Vegetables tests
with Sourcery's own minimalistic testing infrastructure.

Author: rouson

src/test_m.F90

@@ -6,7 +6,7 @@ module test_m
   implicit none
 
   private
-  public :: test_t
+  public :: test_t, test_result_t
 
   type, abstract :: test_t
     !! Facilitate testing and test reporting
@@ -24,7 +24,7 @@ pure function subject_interface() result(specimen)
     end function
 
     function results_interface() result(test_results)
-      !! The result is an array of test outcomes for reporting
+      !! The result is an array of test results for subsequent reporting in the "report" type-bound procedure
       import test_result_t
       type(test_result_t), allocatable :: test_results(:)
     end function

src/test_result_m.f90

@@ -9,18 +9,18 @@ module test_result_m
     !! Encapsulate test descriptions and outcomes and reporting
     private
     character(len=:), allocatable :: description_
-    logical outcome_
+    logical passed_ 
   contains
     procedure :: characterize
   end type
 
   interface test_result_t
 
-    pure module function construct(description, outcome) result(test_result)
+    pure module function construct(description, passed) result(test_result)
       !! The result is a test_result_t object with the components defined by the dummy arguments
       implicit none
       character(len=*), intent(in) :: description
-      logical, intent(in) :: outcome
+      logical, intent(in) :: passed
       type(test_result_t) test_result 
     end function
 
@@ -29,7 +29,7 @@ pure module function construct(description, outcome) result(test_result)
   interface
 
     pure module function characterize(self) result(characterization)
-      !! The result is a character test description and its outcome
+      !! The result is a character description of the test and its outcome
       implicit none
       class(test_result_t), intent(in) :: self
       character(len=:), allocatable :: characterization

src/test_result_s.f90

@@ -5,11 +5,11 @@
 
     module procedure construct
       test_result%description_ = description
-      test_result%outcome_ = outcome
+      test_result%passed_ = passed
     end procedure
 
     module procedure characterize
-      characterization = merge("Pass: ", "Fail: ", self%outcome_) // self%description_
+      characterization = merge("Passes on ", "Fails on  ", self%passed_) // self%description_ // "."
     end procedure
 
 end submodule test_result_s

src/test_s.F90

@@ -19,7 +19,7 @@
       print *, test%subject()
 
       do i=1,size(test_results)
-        print *,"  ",test_results(i)%characterize()
+        print *,"   ",test_results(i)%characterize()
       end do
 #ifndef XLF
     end associate

tests/main.f90

@@ -6,24 +6,28 @@ program main
 contains
     subroutine run()
         use data_partition_test, only: &
-                data_partition_data_partition => test_data_partition
+                data_partition_data_partition => &
+                    test_data_partition
         use formats_test, only: &
-                formats_object => test_object
+                formats_object => &
+                    test_object
         use object_m_test, only: &
-                object_m_object => test_object
-        use user_defined_collectives_test, only: &
-                user_defined_collectives_co_all => test_co_all
+                object_m_object => &
+                    test_object
         use vegetables, only: test_item_t, test_that, run_tests
 
+
+
         type(test_item_t) :: tests
-        type(test_item_t) :: individual_tests(4)
+        type(test_item_t) :: individual_tests(3)
 
         individual_tests(1) = data_partition_data_partition()
         individual_tests(2) = formats_object()
         individual_tests(3) = object_m_object()
-        individual_tests(4) = user_defined_collectives_co_all()
         tests = test_that(individual_tests)
 
+
         call run_tests(tests)
+
     end subroutine
 end program

tests/object_interface_test.f90 renamed to tests/object_m_test.f90

@@ -0,0 +1,8 @@
+program main
+  use user_defined_collectives_test, only : collectives_test_t  
+  implicit none
+
+  type(collectives_test_t) collectives_test
+
+  call collectives_test%report()
+end program

tests/test-driver.f90

@@ -1,43 +1,47 @@
 module user_defined_collectives_test
-    use Vegetables, only: Result_t, Test_Item_t, describe, it, assert_equals, assert_that, assert_not
     use user_defined_collectives_m, only : co_all
+    use test_m, only : test_t, test_result_t
     implicit none
 
     private
-    public :: test_co_all
+    public :: collectives_test_t
+
+    type, extends(test_t) :: collectives_test_t
+    contains
+      procedure, nopass :: subject
+      procedure, nopass :: results
+    end type
 
 contains
 
-    function test_co_all() result(tests)
-        type(Test_Item_t) :: tests
-
-        tests = describe( &
-                "co_all", &
-                [it( &
-                        "sets all arguments to .true. when previously .true. on all images", &
-                        check_co_all_with_all_true), &
-                 it( &
-                        "sets all arguments to .false. when previously .false. on image 1", &
-                        check_co_all_with_one_false)])
-    end function
-
-    function check_co_all_with_all_true() result(result_)
-        type(Result_t) :: result_
-        logical all_true
-
-        all_true=.true.
-
-        call co_all(all_true)
-        result_ = assert_that(all_true, "co_all argument remains .true. after call with all arguments .true.")
-    end function
-
-    function check_co_all_with_one_false() result(result_)
-        type(Result_t) :: result_
-        logical all_true
-
-        all_true = merge(.false., .true., this_image()==1)
-        call co_all(all_true)
-        result_ = assert_not(all_true, "co_all argument is .false. after call with one argument .false.")
-    end function
+  pure function subject() result(specimen)
+    character(len=:), allocatable :: specimen
+    specimen = "The co_all subroutine" 
+  end function
+
+  function results() result(test_results)
+    type(test_result_t), allocatable :: test_results(:)
+
+    test_results = [ &
+      test_result_t("setting all arguments to .true. when previously .true. on all images", check_co_all_with_all_true()), &
+      test_result_t("setting all arguments to .false. when previously .false. on image 1", check_co_all_with_one_false()) &
+    ]
+  end function
+
+  function check_co_all_with_all_true() result(test_passed)
+    logical test_passed, all_true
+
+    all_true=.true.
+    call co_all(all_true)
+    test_passed = all_true
+  end function
+
+  function check_co_all_with_one_false() result(test_passed)
+    logical test_passed, all_true
+
+    all_true = merge(.false., .true., this_image()==1)
+    call co_all(all_true)
+    test_passed = .not. all_true
+  end function
 
 end module user_defined_collectives_test