Collect dummy structs in a central place.

Author: kellertuer

src/AlgorithmsInterface.jl

@@ -20,6 +20,8 @@ include("interface/interface.jl")
 include("stopping_criterion.jl")
 include("logging.jl")
 
+include("test_suite.jl")
+
 # general interface
 export Algorithm, Problem, State
 export initialize_state, initialize_state!

src/stopping_criterion.jl

@@ -54,18 +54,16 @@ indicates_convergence(stopping_criterion::StoppingCriterion)
 @doc """
     indicates_convergence(stopping_criterion::StoppingCriterion, ::StoppingCriterionState)
 
-Return whether or not a [`StoppingCriterion`](@ref) indicates convergence when it is in [`StoppingCriterionState`](@ref).
+Return whether or not a [`StoppingCriterion`](@ref) indicates convergence when it is in [`StoppingCriterionState`](@ref),
+i.e. also check whether the state indicates that the criterion has been active.
 
-By default this checks whether the [`StoppingCriterion`](@ref) has actually stopped.
 If so it returns whether `stopping_criterion` itself indicates convergence, otherwise it returns `false`,
 since the algorithm has then not yet stopped.
 """
 function indicates_convergence(
-        stopping_criterion::StoppingCriterion,
-        stopping_criterion_state::StoppingCriterionState,
+        stopping_criterion::StoppingCriterion, stopping_criterion_state::StoppingCriterionState,
     )
-    return isnothing(get_reason(stopping_criterion, stopping_criterion_state)) &&
-        indicates_convergence(stopping_criterion)
+    return isnothing(get_reason(stopping_criterion, stopping_criterion_state)) && indicates_convergence(stopping_criterion)
 end
 
 _doc_is_finished = """
@@ -86,11 +84,8 @@ once per iteration, the other one merely inspects the current status without mut
 @doc "$(_doc_is_finished)"
 function is_finished(problem::Problem, algorithm::Algorithm, state::State)
     return is_finished(
-        problem,
-        algorithm,
-        state,
-        algorithm.stopping_criterion,
-        state.stopping_criterion_state,
+        problem, algorithm, state,
+        algorithm.stopping_criterion, state.stopping_criterion_state,
     )
 end
 
@@ -100,11 +95,8 @@ is_finished(::Problem, ::Algorithm, ::State, ::StoppingCriterion, ::StoppingCrit
 @doc "$(_doc_is_finished)"
 function is_finished!(problem::Problem, algorithm::Algorithm, state::State)
     return is_finished!(
-        problem,
-        algorithm,
-        state,
-        algorithm.stopping_criterion,
-        state.stopping_criterion_state,
+        problem, algorithm, state,
+        algorithm.stopping_criterion, state.stopping_criterion_state,
     )
 end
 
@@ -115,7 +107,7 @@ is_finished!(::Problem, ::Algorithm, ::State, ::StoppingCriterion, ::StoppingCri
     summary(io::IO, stopping_criterion::StoppingCriterion, stopping_criterion_state::StoppingCriterionState)
 
 Provide a summary of the status of a stopping criterion – its parameters and whether
-it currently indicates to stop. It should not be longer than one line
+it currently indicates to stop.
 
 # Example
 

src/test_suite.jl

@@ -0,0 +1,18 @@
+"""
+    AlgorithmsInterface.Test
+
+The module `AlgorithmsInterface.Test` contains concrete (dummy) instances
+to test prats of the interface.
+"""
+module Test
+    using ..AlgorithmsInterface
+
+    struct DummyAlgorithm{S<:AlgorithmsInterface.StoppingCriterion} <: AlgorithmsInterface.Algorithm
+        stopping_criterion::S
+    end
+    struct DummyProblem <: AlgorithmsInterface.Problem end
+    mutable struct DummyState{S <: AlgorithmsInterface.StoppingCriterionState} <: AlgorithmsInterface.State
+        stopping_criterion_state::S
+        iteration::Int
+    end
+end

test/stopping_criterion.jl

@@ -1,27 +1,20 @@
 using Test
 using AlgorithmsInterface
+using AlgorithmsInterface: Test as AIT
 using Dates
 
-struct DummyAlgorithm <: Algorithm
-    stopping_criterion::StoppingCriterion
-end
-struct DummyProblem <: Problem end
-mutable struct DummyState{S <: StoppingCriterionState} <: State
-    stopping_criterion_state::S
-    iteration::Int
-end
-
-problem = DummyProblem()
+problem = AIT.DummyProblem()
 
 @testset "StopAfterIteration" begin
     s1 = StopAfterIteration(2)
     @test s1 isa StoppingCriterion
-    @test string(s1) == "StopAfterIteration(2)"
-
-    algorithm = DummyAlgorithm(s1)
+    @test repr(s1) == "StopAfterIteration(2)"
+    @test !indicates_convergence(s1)
+    algorithm = AIT.DummyAlgorithm(s1)
     s1_state = initialize_state(problem, algorithm, s1)
-    state_finished = DummyState(s1_state, 2)
-    state_not_finished = DummyState(s1_state, 1)
+    @test !indicates_convergence(s1, s1_state)
+    state_finished = AIT.DummyState(s1_state, 2)
+    state_not_finished = AIT.DummyState(s1_state, 1)
     @test is_finished(problem, algorithm, state_finished)
     @test !is_finished(problem, algorithm, state_not_finished)
 end
@@ -31,28 +24,31 @@ end
     @test s1 isa StoppingCriterion
     @test string(s1) == "StopAfter(Second(1))"
 
-    algorithm = DummyAlgorithm(s1)
+    algorithm = AIT.DummyAlgorithm(s1)
     s1_state = initialize_state(problem, algorithm, s1)
-    state_not_finished = DummyState(s1_state, 1)
+    state_not_finished = AIT.DummyState(s1_state, 1)
     @test !is_finished(problem, algorithm, state_not_finished)
     s1_state.time = Second(2)
     @test is_finished(problem, algorithm, state_not_finished)
 end
 
 @testset "StopWhenAll" begin
     s1 = StopAfterIteration(2) & StopAfter(Second(1))
+    s1b = StopWhenAll([StopAfterIteration(2), StopAfter(Second(1))])
+    @test s1 == s1b
     @test s1 isa StoppingCriterion
     @test sprint((io, x) -> show(io, MIME"text/plain"(), x), s1) ==
         "StopWhenAll with the Stopping Criteria:\n     StopAfterIteration(2)\n     StopAfter(Second(1))"
 
-    algorithm = DummyAlgorithm(s1)
+    algorithm = AIT.DummyAlgorithm(s1)
     s1_state = initialize_state(problem, algorithm, s1)
-    state_not_finished = DummyState(s1_state, 1)
+    state_not_finished = AIT.DummyState(s1_state, 1)
     @test !is_finished(problem, algorithm, state_not_finished)
     s1_state.criteria_states[2].time = Second(2)
     @test !is_finished(problem, algorithm, state_not_finished)
     state_not_finished.iteration = 2
     @test is_finished(problem, algorithm, state_not_finished)
+    @test !indicates_convergence(s1)
 end
 
 @testset "StopWhenAny" begin
@@ -61,9 +57,9 @@ end
     @test sprint((io, x) -> show(io, MIME"text/plain"(), x), s1) ==
         "StopWhenAny with the Stopping Criteria:\n     StopAfterIteration(2)\n     StopAfter(Second(1))"
 
-    algorithm = DummyAlgorithm(s1)
+    algorithm = AIT.DummyAlgorithm(s1)
     s1_state = initialize_state(problem, algorithm, s1)
-    state_not_finished = DummyState(s1_state, 1)
+    state_not_finished = AIT.DummyState(s1_state, 1)
     @test !is_finished(problem, algorithm, state_not_finished)
     s1_state.criteria_states[2].time = Second(2)
     @test is_finished(problem, algorithm, state_not_finished)