[Utilities] improve test coverage

src/MathOptInterface.jl

@@ -394,31 +394,25 @@ import PrecompileTools
 
 PrecompileTools.@setup_workload begin
     PrecompileTools.@compile_workload begin
-        let
-            optimizer =
-                () -> Utilities.MockOptimizer(
-                    Utilities.UniversalFallback(Utilities.Model{Float64}()),
-                )
-            model = Utilities.CachingOptimizer(
-                Utilities.UniversalFallback(Utilities.Model{Float64}()),
-                instantiate(optimizer; with_bridge_type = Float64),
-            )
-            set(model, Silent(), true)
-            x = add_variables(model, 3)
-            add_constraint(model, x[1], ZeroOne())
-            add_constraint(model, x[2], Integer())
-            add_constraint(model, x[1], GreaterThan(0.0))
-            add_constraint(model, x[2], LessThan(0.0))
-            add_constraint(model, x[3], EqualTo(0.0))
-            f = 1.0 * x[1] + x[2] + x[3]
-            add_constraint(model, f, GreaterThan(0.0))
-            add_constraint(model, f, LessThan(0.0))
-            add_constraint(model, f, EqualTo(0.0))
-            y, _ = add_constrained_variables(model, Nonnegatives(2))
-            set(model, ObjectiveSense(), MAX_SENSE)
-            set(model, ObjectiveFunction{typeof(f)}(), f)
-            optimize!(model)
-        end
+        model = Utilities.CachingOptimizer(
+            Utilities.UniversalFallback(Utilities.Model{Float64}()),
+            instantiate(Utilities.MockOptimizer; with_bridge_type = Float64),
+        )
+        set(model, Silent(), true)
+        x = add_variables(model, 3)
+        add_constraint(model, x[1], ZeroOne())
+        add_constraint(model, x[2], Integer())
+        add_constraint(model, x[1], GreaterThan(0.0))
+        add_constraint(model, x[2], LessThan(0.0))
+        add_constraint(model, x[3], EqualTo(0.0))
+        f = 1.0 * x[1] + x[2] + x[3]
+        add_constraint(model, f, GreaterThan(0.0))
+        add_constraint(model, f, LessThan(0.0))
+        add_constraint(model, f, EqualTo(0.0))
+        y, _ = add_constrained_variables(model, Nonnegatives(2))
+        set(model, ObjectiveSense(), MAX_SENSE)
+        set(model, ObjectiveFunction{typeof(f)}(), f)
+        optimize!(model)
     end
 end
 

src/Test/test_attribute.jl

@@ -172,7 +172,7 @@ function test_attribute_TimeLimitSec(model::MOI.AbstractOptimizer, ::Config)
         try
             return MOI.get(model, MOI.TimeLimitSec())
         catch err
-            @assert err isa MOI.GetAttributeNotAllowed(MOI.TimeLimitSec())
+            @assert err isa MOI.GetAttributeNotAllowed{MOI.TimeLimitSec}
         end
         return
     end

src/Utilities/cachingoptimizer.jl

@@ -320,7 +320,8 @@ function MOI.optimize!(m::CachingOptimizer)
         for attr in MOI.get(m, MOI.ListOfModelAttributesSet())
             if attr isa MOI.AbstractCallback
                 attach_optimizer(m)
-                return MOI.optimize!(m)
+                MOI.optimize!(m)
+                return
             end
         end
         indexmap, copied = MOI.optimize!(m.optimizer, m.model_cache)

src/Utilities/mockoptimizer.jl

@@ -131,6 +131,11 @@
     )
 end
 
+function MockOptimizer(::Type{T} = Float64; kwargs...) where {T}
+    inner = UniversalFallback(Utilities.Model{T}())
+    return MockOptimizer(inner, T; kwargs...)
+end
+
 """
 All user-facing indices are xor'd with this mask to produce unusual indices.
 This is good at catching bugs in solvers which assume indices are ordered 1, 2,

src/Utilities/universalfallback.jl

@@ -783,8 +783,7 @@ function MOI.set(
     ci::MOI.ConstraintIndex{F,S},
     value,
 ) where {F,S}
-    if MOI.supports_constraint(uf.model, F, S) &&
-       MOI.supports(uf.model, attr, MOI.ConstraintIndex{F,S})
+    if _model_supports_attribute(uf.model, attr, MOI.ConstraintIndex{F,S})
         MOI.set(uf.model, attr, ci, value)
     else
         _set(uf, attr, ci, value)

test/Test/Test.jl

@@ -246,6 +246,31 @@ function test_error_handler()
     return
 end
 
+"Test a model that errors getting time limit unless it was previously set"
+mutable struct ModelTimeLimitSecErrorIfNotSet <: MOI.AbstractOptimizer
+    time_limit::Union{Missing,Nothing,Float64}
+end
+
+MOI.supports(::ModelTimeLimitSecErrorIfNotSet, ::MOI.TimeLimitSec) = true
+
+function MOI.get(model::ModelTimeLimitSecErrorIfNotSet, attr::MOI.TimeLimitSec)
+    if model.time_limit === missing
+        throw(MOI.GetAttributeNotAllowed(attr))
+    end
+    return model.time_limit::Union{Nothing,Float64}
+end
+
+function MOI.set(model::ModelTimeLimitSecErrorIfNotSet, ::MOI.TimeLimitSec, v)
+    model.time_limit = v
+    return
+end
+
+function test_attribute_TimeLimitSec()
+    model = ModelTimeLimitSecErrorIfNotSet(missing)
+    MOI.Test.test_attribute_TimeLimitSec(model, MOI.Test.Config())
+    return
+end
+
 end  # module
 
 TestTest.runtests()

test/Utilities/cachingoptimizer.jl

@@ -1403,6 +1403,68 @@ function test_pass_nonvariable_constraints()
     return
 end
 
+function test_optimize_abstract_callback()
+    inner = MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}())
+    optimizer = MOI.Utilities.MockOptimizer(inner)
+    model = MOI.Utilities.CachingOptimizer(
+        MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}()),
+        optimizer,
+    )
+    x, _ = MOI.add_constrained_variable(model, MOI.Integer())
+    function callback_fn(cb_data)
+        _ = MOI.submit(model, MOI.HeuristicSolution(cb_data), [x], [1.0])
+        return
+    end
+    MOI.set(model, MOI.HeuristicCallback(), callback_fn)
+    MOI.optimize!(model)
+    @test model.state == MOI.Utilities.ATTACHED_OPTIMIZER
+    @test optimizer.optimize_called
+    return
+end
+
+struct ErrorOnSetAttributeModel <: MOI.ModelLike end
+
+MOI.is_empty(::ErrorOnSetAttributeModel) = true
+
+function MOI.copy_to(::ErrorOnSetAttributeModel, src::MOI.ModelLike)
+    return MOI.Utilities.identity_index_map(src)
+end
+
+function MOI.set(
+    ::ErrorOnSetAttributeModel,
+    ::MOI.ObjectiveSense,
+    ::MOI.OptimizationSense,
+)
+    return error("Something other than unsupported model attribute")
+end
+
+function MOI.set(
+    ::ErrorOnSetAttributeModel,
+    ::MOI.VariablePrimalStart,
+    ::MOI.VariableIndex,
+    ::Float64,
+)
+    return error("Something other than unsupported variable attribute")
+end
+
+function test_rethrow_set_model_attribute()
+    model = MOI.Utilities.CachingOptimizer(
+        MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}()),
+        ErrorOnSetAttributeModel(),
+    )
+    x = MOI.add_variable(model)
+    MOI.Utilities.attach_optimizer(model)
+    @test_throws(
+        ErrorException("Something other than unsupported model attribute"),
+        MOI.set(model, MOI.ObjectiveSense(), MOI.MIN_SENSE),
+    )
+    @test_throws(
+        ErrorException("Something other than unsupported variable attribute"),
+        MOI.set(model, MOI.VariablePrimalStart(), x, 1.0),
+    )
+    return
+end
+
 end  # module
 
 TestCachingOptimizer.runtests()

test/Utilities/mockoptimizer.jl

@@ -285,6 +285,28 @@ function test_is_set_by_optimize_optimizer_attribute()
     return
 end
 
+function test_empty_constructor()
+    mock = MOI.Utilities.MockOptimizer(Int; supports_names = false)
+    @test mock.supports_names == false
+    @test isa(
+        mock,
+        MOI.Utilities.MockOptimizer{
+            MOI.Utilities.UniversalFallback{MOI.Utilities.Model{Int}},
+            Int,
+        },
+    )
+    mock = MOI.Utilities.MockOptimizer()
+    @test mock.supports_names
+    @test isa(
+        mock,
+        MOI.Utilities.MockOptimizer{
+            MOI.Utilities.UniversalFallback{MOI.Utilities.Model{Float64}},
+            Float64,
+        },
+    )
+    return
+end
+
 end  # module
 
 TestMockOptimizer.runtests()

test/Utilities/universalfallback.jl

@@ -434,6 +434,8 @@ function test_throw_unsupported_variable_constraint()
         MOI.UnsupportedConstraint{typeof(x),typeof(set)}(),
         MOI.Utilities.throw_unsupported(model),
     )
+    MOI.delete(model, c)
+    @test MOI.Utilities.throw_unsupported(model) === nothing
     return
 end
 
@@ -447,6 +449,8 @@ function test_throw_unsupported_affine_constraint()
         MOI.UnsupportedConstraint{typeof(func),typeof(set)}(),
         MOI.Utilities.throw_unsupported(model),
     )
+    MOI.delete(model, c)
+    @test MOI.Utilities.throw_unsupported(model) === nothing
     return
 end
 
@@ -516,6 +520,16 @@ function test_delete_ci_attribute()
     return
 end
 
+function test_set_inner_constraint_attribute()
+    inner = MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}())
+    model = MOI.Utilities.UniversalFallback(inner)
+    x = MOI.add_variable(model)
+    c = MOI.add_constraint(model, x, MOI.GreaterThan(1.0))
+    MOI.set(model, MOI.ConstraintPrimalStart(), c, 1.0)
+    @test MOI.get(model, MOI.ConstraintPrimalStart(), c) == 1.0
+    return
+end
+
 end  # module
 
 TestUniversalFallback.runtests()