Skip to content

Commit 18d8b3c

Browse files
ocotsocots
committed
feat: integrate CTSolvers.Strategies parameter functions in tests
- Add tests for is_parameter_type, available_parameters, get_parameter_type - Improve test_registry.jl with parameter validation using CTSolvers functions - Enhance test_dispatch_logic.jl with parametric mocks for parameter testing - Complete test_ctsolvers.jl coverage for all reexported symbols - Fix comment in ctsolvers.jl imports (parameter types are import-only) - Add missing tests for describe and options functions All tests pass with comprehensive coverage of CTSolvers parameter validation functions and proper verification of reexport vs import-only symbols.
1 parent 6d1a205 commit 18d8b3c

4 files changed

Lines changed: 151 additions & 14 deletions

File tree

‎src/imports/ctmodels.jl‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -27,9 +27,7 @@ import CTModels:
2727
# api types
2828
Model,
2929
AbstractModel,
30-
AbstractModel,
31-
Solution,
32-
AbstractSolution,
30+
Solution,
3331
AbstractSolution
3432

3533
@reexport import CTModels:

‎test/suite/helpers/test_registry.jl‎

Lines changed: 51 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -56,23 +56,56 @@ function test_registry()
5656
Test.@testset "Parameter Support - Modelers" begin
5757
registry = OptimalControl.get_strategy_registry()
5858

59-
# The registry structure tells us which parameters are supported
60-
# ADNLP should only support CPU (checked via registry structure)
61-
# Exa should support both CPU and GPU (checked via registry structure)
59+
# Test parameter availability using CTSolvers functions
60+
adnlp_params = CTSolvers.Strategies.available_parameters(:modeler, CTSolvers.AbstractNLPModeler, registry)
61+
exa_params = CTSolvers.Strategies.available_parameters(:modeler, CTSolvers.AbstractNLPModeler, registry)
6262

63-
# Test that registry contains parameter information
64-
# This is verified through the registry structure itself
65-
Test.@test registry isa CTSolvers.StrategyRegistry
63+
# Filter parameters for specific strategies
64+
adnlp_filtered = CTSolvers.Strategies.available_parameters(:adnlp, CTSolvers.AbstractNLPModeler, registry)
65+
exa_filtered = CTSolvers.Strategies.available_parameters(:exa, CTSolvers.AbstractNLPModeler, registry)
66+
67+
# ADNLP should only support CPU
68+
Test.@test CTSolvers.CPU in adnlp_filtered
69+
Test.@test CTSolvers.GPU ∉ adnlp_filtered
70+
71+
# Exa should support both CPU and GPU
72+
Test.@test CTSolvers.CPU in exa_filtered
73+
Test.@test CTSolvers.GPU in exa_filtered
74+
75+
# Test parameter type extraction
76+
Test.@test CTSolvers.Strategies.get_parameter_type(CTSolvers.ADNLP) === nothing
77+
Test.@test CTSolvers.Strategies.get_parameter_type(CTSolvers.Exa) === nothing
6678
end
6779

6880
Test.@testset "Parameter Support - Solvers" begin
6981
registry = OptimalControl.get_strategy_registry()
7082

71-
# CPU-only solvers (Ipopt, Knitro) and GPU-capable solvers (MadNLP, MadNCL)
72-
# are distinguished by their parameter lists in the registry
83+
# Test parameter availability using CTSolvers functions with abstract types
84+
# Filter parameters for specific strategies
85+
ipopt_filtered = CTSolvers.Strategies.available_parameters(:ipopt, CTSolvers.AbstractNLPSolver, registry)
86+
madnlp_filtered = CTSolvers.Strategies.available_parameters(:madnlp, CTSolvers.AbstractNLPSolver, registry)
87+
madncl_filtered = CTSolvers.Strategies.available_parameters(:madncl, CTSolvers.AbstractNLPSolver, registry)
88+
knitro_filtered = CTSolvers.Strategies.available_parameters(:knitro, CTSolvers.AbstractNLPSolver, registry)
7389

74-
# Test that registry contains parameter information
75-
Test.@test registry isa CTSolvers.StrategyRegistry
90+
# CPU-only solvers
91+
Test.@test CTSolvers.CPU in ipopt_filtered
92+
Test.@test CTSolvers.GPU ∉ ipopt_filtered
93+
94+
Test.@test CTSolvers.CPU in knitro_filtered
95+
Test.@test CTSolvers.GPU ∉ knitro_filtered
96+
97+
# GPU-capable solvers
98+
Test.@test CTSolvers.CPU in madnlp_filtered
99+
Test.@test CTSolvers.GPU in madnlp_filtered
100+
101+
Test.@test CTSolvers.CPU in madncl_filtered
102+
Test.@test CTSolvers.GPU in madncl_filtered
103+
104+
# Test parameter type extraction
105+
Test.@test CTSolvers.Strategies.get_parameter_type(CTSolvers.Ipopt) === nothing
106+
Test.@test CTSolvers.Strategies.get_parameter_type(CTSolvers.MadNLP) === nothing
107+
Test.@test CTSolvers.Strategies.get_parameter_type(CTSolvers.MadNCL) === nothing
108+
Test.@test CTSolvers.Strategies.get_parameter_type(CTSolvers.Knitro) === nothing
76109
end
77110

78111
Test.@testset "Parameter Type Validation" begin
@@ -90,6 +123,14 @@ function test_registry()
90123
# Test that strategies are not parameters
91124
Test.@test CTSolvers.Exa !== CTSolvers.CPU
92125
Test.@test CTSolvers.Ipopt !== CTSolvers.GPU
126+
127+
# Test parameter type identification using CTSolvers functions
128+
Test.@test CTSolvers.Strategies.is_parameter_type(CTSolvers.CPU)
129+
Test.@test CTSolvers.Strategies.is_parameter_type(CTSolvers.GPU)
130+
Test.@test !CTSolvers.Strategies.is_parameter_type(CTSolvers.Exa)
131+
Test.@test !CTSolvers.Strategies.is_parameter_type(CTSolvers.Ipopt)
132+
Test.@test !CTSolvers.Strategies.is_parameter_type(Int)
133+
Test.@test !CTSolvers.Strategies.is_parameter_type(String)
93134
end
94135

95136
Test.@testset "Determinism" begin

‎test/suite/reexport/test_ctsolvers.jl‎

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
module TestCtsolvers
99

1010
import Test
11+
import CTSolvers
1112
using OptimalControl # using is mandatory since we test exported symbols
1213

1314
const VERBOSE = isdefined(Main, :TestOptions) ? Main.TestOptions.VERBOSE : true
@@ -26,6 +27,7 @@ function test_ctsolvers()
2627
Test.@test T isa DataType || T isa UnionAll
2728
end
2829
end
30+
2931
Test.@testset "DOCP Functions" begin
3032
for f in (
3133
:ocp_model,
@@ -39,6 +41,19 @@ function test_ctsolvers()
3941
end
4042
end
4143
end
44+
45+
Test.@testset "Display and Introspection Functions" begin
46+
for f in (
47+
:describe,
48+
:options,
49+
)
50+
Test.@testset "$f" begin
51+
Test.@test isdefined(OptimalControl, f)
52+
Test.@test isdefined(CurrentModule, f)
53+
Test.@test getfield(OptimalControl, f) isa Function
54+
end
55+
end
56+
end
4257
Test.@testset "Modeler Types" begin
4358
for T in (
4459
OptimalControl.AbstractNLPModeler,
@@ -124,6 +139,34 @@ function test_ctsolvers()
124139
end
125140
end
126141
end
142+
143+
Test.@testset "Strategy Parameter Types" begin
144+
# Test that parameter types are available but NOT reexported
145+
# They should be accessible via isdefined but not in exports
146+
Test.@test isdefined(OptimalControl, :AbstractStrategyParameter)
147+
Test.@test isdefined(OptimalControl, :CPU)
148+
Test.@test isdefined(OptimalControl, :GPU)
149+
150+
# They should NOT be in the public exports (names with all=false)
151+
Test.@test :AbstractStrategyParameter ∉ names(OptimalControl; all=false)
152+
Test.@test :CPU ∉ names(OptimalControl; all=false)
153+
Test.@test :GPU ∉ names(OptimalControl; all=false)
154+
155+
# They should also be accessible via CTSolvers
156+
Test.@test isdefined(CTSolvers, :AbstractStrategyParameter)
157+
Test.@test isdefined(CTSolvers, :CPU)
158+
Test.@test isdefined(CTSolvers, :GPU)
159+
160+
# Test parameter type validation functions are accessible via CTSolvers
161+
Test.@test isdefined(CTSolvers.Strategies, :is_parameter_type)
162+
Test.@test isdefined(CTSolvers.Strategies, :get_parameter_type)
163+
Test.@test isdefined(CTSolvers.Strategies, :available_parameters)
164+
165+
# These should NOT be reexported by OptimalControl (internal functions)
166+
Test.@test !isdefined(OptimalControl, :is_parameter_type)
167+
Test.@test !isdefined(OptimalControl, :get_parameter_type)
168+
Test.@test !isdefined(OptimalControl, :available_parameters)
169+
end
127170
end
128171
end
129172

‎test/suite/solve/test_dispatch_logic.jl‎

Lines changed: 56 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,15 @@ struct MockSolver{ID} <: CTSolvers.AbstractNLPSolver
4242
options::CTSolvers.StrategyOptions
4343
end
4444

45+
# Parametric mocks for parameterized strategies (CPU/GPU)
46+
struct MockModelerParam{ID, PARAM} <: CTSolvers.AbstractNLPModeler
47+
options::CTSolvers.StrategyOptions
48+
end
49+
50+
struct MockSolverParam{ID, PARAM} <: CTSolvers.AbstractNLPSolver
51+
options::CTSolvers.StrategyOptions
52+
end
53+
4554
# ----------------------------------------------------------------------------
4655
# Strategies Interface Implementation
4756
# ----------------------------------------------------------------------------
@@ -50,16 +59,22 @@ end
5059
CTSolvers.Strategies.id(::Type{MockDiscretizer{ID}}) where {ID} = ID
5160
CTSolvers.Strategies.id(::Type{MockModeler{ID}}) where {ID} = ID
5261
CTSolvers.Strategies.id(::Type{MockSolver{ID}}) where {ID} = ID
62+
CTSolvers.Strategies.id(::Type{MockModelerParam{ID, PARAM}}) where {ID, PARAM} = ID
63+
CTSolvers.Strategies.id(::Type{MockSolverParam{ID, PARAM}}) where {ID, PARAM} = ID
5364

5465
# Metadata (required by registry)
5566
CTSolvers.Strategies.metadata(::Type{<:MockDiscretizer}) = CTSolvers.Strategies.StrategyMetadata()
5667
CTSolvers.Strategies.metadata(::Type{<:MockModeler}) = CTSolvers.Strategies.StrategyMetadata()
5768
CTSolvers.Strategies.metadata(::Type{<:MockSolver}) = CTSolvers.Strategies.StrategyMetadata()
69+
CTSolvers.Strategies.metadata(::Type{<:MockModelerParam}) = CTSolvers.Strategies.StrategyMetadata()
70+
CTSolvers.Strategies.metadata(::Type{<:MockSolverParam}) = CTSolvers.Strategies.StrategyMetadata()
5871

5972
# Options accessors
6073
CTSolvers.Strategies.options(d::MockDiscretizer) = d.options
6174
CTSolvers.Strategies.options(m::MockModeler) = m.options
6275
CTSolvers.Strategies.options(s::MockSolver) = s.options
76+
CTSolvers.Strategies.options(m::MockModelerParam) = m.options
77+
CTSolvers.Strategies.options(s::MockSolverParam) = s.options
6378

6479
# Constructors (required by _build_or_use_strategy)
6580
function MockDiscretizer{ID}(; mode::Symbol=:strict, kwargs...) where {ID}
@@ -77,6 +92,16 @@ function MockSolver{ID}(; mode::Symbol=:strict, kwargs...) where {ID}
7792
return MockSolver{ID}(opts)
7893
end
7994

95+
function MockModelerParam{ID, PARAM}(; mode::Symbol=:strict, kwargs...) where {ID, PARAM}
96+
opts = CTSolvers.Strategies.build_strategy_options(MockModelerParam{ID, PARAM}; mode=mode, kwargs...)
97+
return MockModelerParam{ID, PARAM}(opts)
98+
end
99+
100+
function MockSolverParam{ID, PARAM}(; mode::Symbol=:strict, kwargs...) where {ID, PARAM}
101+
opts = CTSolvers.Strategies.build_strategy_options(MockSolverParam{ID, PARAM}; mode=mode, kwargs...)
102+
return MockSolverParam{ID, PARAM}(opts)
103+
end
104+
80105
# ----------------------------------------------------------------------------
81106
# Mock Registry Builder
82107
# ----------------------------------------------------------------------------
@@ -232,7 +257,37 @@ function test_dispatch_logic()
232257
end
233258

234259
# ----------------------------------------------------------------
235-
# TEST 4: Default Registry Fallback
260+
# TEST 5: Parameter Type Validation
261+
# ----------------------------------------------------------------
262+
# Test that CTSolvers parameter functions work correctly with our mocks
263+
264+
Test.@testset "Parameter Type Validation" begin
265+
# Test parameter type identification
266+
Test.@test CTSolvers.Strategies.is_parameter_type(CTSolvers.CPU)
267+
Test.@test CTSolvers.Strategies.is_parameter_type(CTSolvers.GPU)
268+
Test.@test !CTSolvers.Strategies.is_parameter_type(Int)
269+
270+
# Test parameter extraction from non-parameterized mocks
271+
# Our mocks don't have type parameters in the way CTSolvers expects
272+
# so get_parameter_type should return nothing
273+
Test.@test CTSolvers.Strategies.get_parameter_type(MockModeler{:adnlp}) === nothing
274+
Test.@test CTSolvers.Strategies.get_parameter_type(MockSolver{:ipopt}) === nothing
275+
276+
# Test parameter extraction from parameterized mocks
277+
# Even with parameters, our mocks don't follow the CTSolvers convention
278+
# so get_parameter_type should still return nothing
279+
Test.@test CTSolvers.Strategies.get_parameter_type(MockModelerParam{:exa, CTSolvers.CPU}) === nothing
280+
Test.@test CTSolvers.Strategies.get_parameter_type(MockSolverParam{:madnlp, CTSolvers.GPU}) === nothing
281+
282+
# Test that is_parameter_type works correctly for real CTSolvers types
283+
Test.@test CTSolvers.Strategies.is_parameter_type(CTSolvers.CPU)
284+
Test.@test CTSolvers.Strategies.is_parameter_type(CTSolvers.GPU)
285+
Test.@test !CTSolvers.Strategies.is_parameter_type(CTSolvers.ADNLP)
286+
Test.@test !CTSolvers.Strategies.is_parameter_type(CTSolvers.Ipopt)
287+
end
288+
289+
# ----------------------------------------------------------------
290+
# TEST 6: Default Registry Fallback
236291
# ----------------------------------------------------------------
237292
# Verify that if we don't pass `registry`, it falls back to the real one.
238293

0 commit comments

Comments
 (0)