update tests

Author: lkdvos

test/logging.jl

@@ -13,27 +13,26 @@ mutable struct LogDummyState{S <: StoppingCriterionState} <: State
 end
 
 # State initialization for the dummy algorithm
-function AlgorithmsInterface.initialize_state(problem::LogDummyProblem, algorithm::LogDummyAlgorithm; kwargs...)
-    sc_state = initialize_state(problem, algorithm, algorithm.stopping_criterion; kwargs...)
-    return LogDummyState(0.0, 0, sc_state)
+function AlgorithmsInterface.initialize_state(
+        problem::LogDummyProblem, algorithm::LogDummyAlgorithm,
+        stopping_criterion_state::StoppingCriterionState;
+        kwargs...
+    )
+    iteration = 0
+    iterate = 0.0 # hardcode initial guess to 0.0
+    return LogDummyState(iterate, iteration, stopping_criterion_state)
 end
 function AlgorithmsInterface.initialize_state!(
-        problem::LogDummyProblem,
-        algorithm::LogDummyAlgorithm,
-        state::LogDummyState;
+        problem::LogDummyProblem, algorithm::LogDummyAlgorithm, state::LogDummyState;
         kwargs...
     )
-    initialize_state!(problem, algorithm, algorithm.stopping_criterion, state.stopping_criterion_state; kwargs...)
-    state.iterate = 0.0
     state.iteration = 0
     return state
 end
 
 # One trivial step per iteration (not relevant for the logging test)
 function AlgorithmsInterface.step!(
-        ::LogDummyProblem,
-        ::LogDummyAlgorithm,
-        state::LogDummyState,
+        ::LogDummyProblem, ::LogDummyAlgorithm, state::LogDummyState,
     )
     state.iterate += 1.0
     return state

test/newton.jl

@@ -25,23 +25,21 @@ end
 
 # Implementing the algorithm
 # --------------------------
-function initialize_state(problem::RootFindingProblem, algorithm::NewtonMethod)
-    scs = initialize_state(problem, algorithm, algorithm.stopping_criterion)
-    return NewtonState(0, 1.0, scs) # hardcode initial guess to 1.0
+function initialize_state(
+        problem::RootFindingProblem, algorithm::NewtonMethod,
+        stopping_criterion_state::StoppingCriterionState;
+        kwargs...
+    )
+    iteration = 0
+    iterate = 1.0 # hardcode initial guess to 1.0
+    return NewtonState(iteration, iterate, stopping_criterion_state)
 end
+
 function initialize_state!(
-        problem::RootFindingProblem,
-        algorithm::NewtonMethod,
-        state::NewtonState,
+        problem::RootFindingProblem, algorithm::NewtonMethod, state::NewtonState;
+        kwargs...
     )
     state.iteration = 0
-    state.iterate = 1.0
-    initialize_state!(
-        problem,
-        algorithm,
-        algorithm.stopping_criterion,
-        state.stopping_criterion_state,
-    )
     return state
 end
 

test/stopping_criterion.jl

@@ -5,12 +5,21 @@ 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
 
+function AlgorithmsInterface.initialize_state(
+        problem::DummyProblem, algorithm::DummyAlgorithm, stopping_criterion_state::StoppingCriterionState;
+        kwargs...
+    )
+    return DummyState(stopping_criterion_state, 1)
+end
+
 problem = DummyProblem()
 
 @testset "StopAfterIteration" begin
@@ -19,11 +28,10 @@ problem = DummyProblem()
     @test string(s1) == "StopAfterIteration(2)"
 
     algorithm = DummyAlgorithm(s1)
-    s1_state = initialize_state(problem, algorithm, s1)
-    state_finished = DummyState(s1_state, 2)
-    state_not_finished = DummyState(s1_state, 1)
-    @test is_finished(problem, algorithm, state_finished)
-    @test !is_finished(problem, algorithm, state_not_finished)
+    state = initialize_state(problem, algorithm)
+    @test !is_finished(problem, algorithm, state)
+    AlgorithmsInterface.increment!(state)
+    @test is_finished(problem, algorithm, state)
 end
 
 @testset "StopAfter" begin
@@ -32,11 +40,10 @@ end
     @test string(s1) == "StopAfter(Second(1))"
 
     algorithm = DummyAlgorithm(s1)
-    s1_state = initialize_state(problem, algorithm, s1)
-    state_not_finished = 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)
+    state = initialize_state(problem, algorithm)
+    @test !is_finished(problem, algorithm, state)
+    state.stopping_criterion_state.time = Second(2)
+    @test is_finished(problem, algorithm, state)
 end
 
 @testset "StopWhenAll" begin
@@ -46,13 +53,12 @@ end
         "StopWhenAll with the Stopping Criteria:\n     StopAfterIteration(2)\n     StopAfter(Second(1))"
 
     algorithm = DummyAlgorithm(s1)
-    s1_state = initialize_state(problem, algorithm, s1)
-    state_not_finished = 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)
+    state = initialize_state(problem, algorithm)
+    @test !is_finished(problem, algorithm, state)
+    state.stopping_criterion_state.criteria_states[2].time = Second(2)
+    @test !is_finished(problem, algorithm, state)
+    AlgorithmsInterface.increment!(state)
+    @test is_finished(problem, algorithm, state)
 end
 
 @testset "StopWhenAny" begin
@@ -62,11 +68,10 @@ end
         "StopWhenAny with the Stopping Criteria:\n     StopAfterIteration(2)\n     StopAfter(Second(1))"
 
     algorithm = DummyAlgorithm(s1)
-    s1_state = initialize_state(problem, algorithm, s1)
-    state_not_finished = 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)
+    state = initialize_state(problem, algorithm)
+    @test !is_finished(problem, algorithm, state)
+    state.stopping_criterion_state.criteria_states[2].time = Second(2)
+    @test is_finished(problem, algorithm, state)
+    AlgorithmsInterface.increment!(state)
+    @test is_finished(problem, algorithm, state)
 end