Refactor tests

test/Bridges/Bridges.jl

@@ -0,0 +1,23 @@
+using Test
+
+@testset "BridgeOptimizer" begin
+    include("bridgeoptimizer.jl")
+end
+@testset "LazyBridgeOptimizer" begin
+    include("lazybridgeoptimizer.jl")
+end
+@testset "Separate bridges" begin
+    include("flip_sign_bridge.jl")
+    include("vectorizebridge.jl")
+    include("scalarizebridge.jl")
+    include("slackbridge.jl")
+    include("functionize_bridge.jl")
+    include("intervalbridge.jl")
+    include("rsocbridge.jl")
+    include("quadtosocbridge.jl")
+    include("geomeanbridge.jl")
+    include("squarepsdbridge.jl")
+    include("detbridge.jl")
+    include("soctopsdbridge.jl")
+end
+include("external.jl")

test/Bridges/bridgeoptimizer.jl

@@ -0,0 +1,99 @@
+using Test
+
+using MathOptInterface
+const MOI = MathOptInterface
+const MOIT = MathOptInterface.Test
+const MOIU = MathOptInterface.Utilities
+const MOIB = MathOptInterface.Bridges
+
+include("simple_model.jl")
+include("utilities.jl")
+
+struct UnknownConstraintAttribute <: MOI.AbstractConstraintAttribute end
+MOI.is_set_by_optimize(::UnknownConstraintAttribute) = true
+
+mock = MOIU.MockOptimizer(SimpleModel{Float64}())
+bridged_mock = MOIB.SplitInterval{Float64}(mock)
+
+@testset "Unsupported constraint attribute" begin
+    attr = UnknownConstraintAttribute()
+    err = ArgumentError(
+        "Constraint bridge of type `MathOptInterface.Bridges.SplitIntervalBridge{Float64,MathOptInterface.SingleVariable}` " *
+        "does not support accessing the attribute `$attr`.")
+    x = MOI.add_variable(bridged_mock)
+    ci = MOI.add_constraint(bridged_mock, MOI.SingleVariable(x),
+                            MOI.Interval(0.0, 1.0))
+    @test_throws err MOI.get(bridged_mock, attr, ci)
+end
+
+@testset "Issue #453" begin
+    MOI.empty!(bridged_mock)
+    MOIU.loadfromstring!(bridged_mock, """
+        variables: x
+        maxobjective: 3.0x
+        c: 2.0x in Interval(1.0, 4.0)
+        d: x in LessThan(1.5)
+    """)
+    x = MOI.get(bridged_mock, MOI.VariableIndex, "x")
+    @test isa(x, MOI.VariableIndex)
+    c1 = MOI.get(bridged_mock, MOI.ConstraintIndex{MOI.ScalarAffineFunction{Float64}, MOI.Interval{Float64}}, "c")
+    @test isa(c1, MOI.ConstraintIndex{MOI.ScalarAffineFunction{Float64}, MOI.Interval{Float64}})
+    c2 = MOI.get(bridged_mock, MOI.ConstraintIndex, "c")
+    @test c1 == c2
+    d1 = MOI.get(bridged_mock, MOI.ConstraintIndex{MOI.SingleVariable, MOI.LessThan{Float64}}, "d")
+    @test isa(d1, MOI.ConstraintIndex{MOI.SingleVariable, MOI.LessThan{Float64}})
+    d2 = MOI.get(bridged_mock, MOI.ConstraintIndex, "d")
+    @test d1 == d2
+end
+
+MOI.empty!(bridged_mock)
+
+@testset "Name test" begin
+    MOIT.nametest(bridged_mock)
+end
+
+@testset "Copy test" begin
+    MOIT.failcopytestc(bridged_mock)
+    MOIT.failcopytestia(bridged_mock)
+    MOIT.failcopytestva(bridged_mock)
+    MOIT.failcopytestca(bridged_mock)
+    MOIT.copytest(bridged_mock, SimpleModel{Float64}())
+end
+
+@testset "Custom test" begin
+    model = MOIB.SplitInterval{Int}(SimpleModel{Int}())
+    @test !MOIB.supports_bridging_constraint(model, MOI.VectorAffineFunction{Float64}, MOI.Interval{Float64})
+
+    x, y = MOI.add_variables(model, 2)
+    @test MOI.get(model, MOI.NumberOfVariables()) == 2
+
+    f1 = MOI.ScalarAffineFunction([MOI.ScalarAffineTerm(3, x)], 7)
+    c1 = MOI.add_constraint(model, f1, MOI.Interval(-1, 1))
+
+    @test MOI.get(model, MOI.ListOfConstraints()) == [(MOI.ScalarAffineFunction{Int},MOI.Interval{Int})]
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.GreaterThan{Int}, 0)
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.Interval{Int}, 1)
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.Interval{Int}}())) == [c1]
+
+    f2 = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.([2, -1], [x, y]), 2)
+    c2 = MOI.add_constraint(model, f1, MOI.GreaterThan(-2))
+
+    @test MOI.get(model, MOI.ListOfConstraints()) == [(MOI.ScalarAffineFunction{Int},MOI.GreaterThan{Int}), (MOI.ScalarAffineFunction{Int},MOI.Interval{Int})]
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.GreaterThan{Int}, 1)
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.Interval{Int}, 1)
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.Interval{Int}}())) == [c1]
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.GreaterThan{Int}}())) == [c2]
+
+    @test MOI.is_valid(model, c2)
+    MOI.delete(model, c2)
+
+    @test MOI.get(model, MOI.ListOfConstraints()) == [(MOI.ScalarAffineFunction{Int},MOI.Interval{Int})]
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.GreaterThan{Int}, 0)
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.Interval{Int}, 1)
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.Interval{Int}}())) == [c1]
+end
+
+@testset "Continuous Linear" begin
+    exclude = ["partial_start"] # VariablePrimalStart not supported.
+    MOIT.contlineartest(bridged_mock, MOIT.TestConfig(solve=false), exclude)
+end

test/Bridges/detbridge.jl

@@ -0,0 +1,21 @@
+@testset "LogDet" begin
+    bridged_mock = MOIB.LogDet{Float64}(mock)
+    mock.optimize! = (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 1, 0, 1, 1, 0, 1, 0, 0, 1])
+    MOIT.logdett1vtest(bridged_mock, config)
+    MOIT.logdett1ftest(bridged_mock, config)
+    # Dual is not yet implemented for LogDet bridge
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.LogDetConeTriangle}()))
+    test_delete_bridge(bridged_mock, ci, 5, ((MOI.VectorAffineFunction{Float64}, MOI.ExponentialCone, 0), (MOI.VectorAffineFunction{Float64}, MOI.PositiveSemidefiniteConeTriangle, 0)))
+end
+
+@testset "RootDet" begin
+    bridged_mock = MOIB.RootDet{Float64}(mock)
+    mock.optimize! = (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [1, 1, 0, 1, 1, 0, 1])
+    MOIT.rootdett1vtest(bridged_mock, config)
+    MOIT.rootdett1ftest(bridged_mock, config)
+    # Dual is not yet implemented for RootDet bridge
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.RootDetConeTriangle}()))
+    test_delete_bridge(bridged_mock, ci, 4, ((MOI.VectorAffineFunction{Float64}, MOI.RotatedSecondOrderCone, 0),
+                                            (MOI.VectorAffineFunction{Float64}, MOI.GeometricMeanCone, 0),
+                                            (MOI.VectorAffineFunction{Float64}, MOI.PositiveSemidefiniteConeTriangle, 0)))
+end

test/Bridges/external.jl

@@ -0,0 +1,61 @@
+using Test
+
+using MathOptInterface
+const MOI = MathOptInterface
+const MOIU = MathOptInterface.Utilities
+
+include("simple_model.jl")
+
+# We need to test this in a module at the top level because it can't be defined
+# in a testset. If it runs without error, then we're okay.
+module TestExternalBridge
+    using MathOptInterface
+
+    struct StrictlyGreaterThan <: MathOptInterface.AbstractScalarSet end
+    struct StrictlyGreaterBridge{T} <: MathOptInterface.Bridges.AbstractBridge end
+
+    function StrictlyGreaterBridge(
+            model,
+            func::MathOptInterface.SingleVariable,
+            set::StrictlyGreaterThan)
+        return StrictlyGreaterBridge{Float64}()
+    end
+
+    function MathOptInterface.supports_constraint(
+            ::Type{StrictlyGreaterBridge{T}},
+            ::Type{MathOptInterface.SingleVariable},
+            ::Type{StrictlyGreaterThan}) where {T}
+        return true
+    end
+
+    function MathOptInterface.Bridges.added_constraint_types(
+            ::Type{StrictlyGreaterBridge{T}},
+            ::Type{MathOptInterface.SingleVariable},
+            ::Type{StrictlyGreaterThan}) where {T}
+        return [(
+            MathOptInterface.SingleVariable,
+            MathOptInterface.GreaterThan{T}
+        )]
+    end
+
+    MathOptInterface.Bridges.@bridge(StrictlyGreater, StrictlyGreaterBridge,
+        (StrictlyGreaterThan, ),
+        (),
+        (),
+        (),
+        (MathOptInterface.SingleVariable, ),
+        (),
+        (),
+        ()
+    )
+end
+
+@testset "@bridge with external components" begin
+    model = SimpleModel{Float64}();
+    @test MOI.supports_constraint(model, MOI.SingleVariable, MOI.GreaterThan{Float64})
+    @test !MOI.supports_constraint(model, MOI.SingleVariable, TestExternalBridge.StrictlyGreaterThan)
+
+    bridge = TestExternalBridge.StrictlyGreater{Float64}(model);
+    @test MOI.supports_constraint(bridge, MOI.SingleVariable, MOI.GreaterThan{Float64})
+    @test MOI.supports_constraint(bridge, MOI.SingleVariable, TestExternalBridge.StrictlyGreaterThan)
+end

test/Bridges/flip_sign_bridge.jl

@@ -0,0 +1,107 @@
+include("simple_model.jl")
+
+mock = MOIU.MockOptimizer(SimpleModel{Float64}())
+config = MOIT.TestConfig()
+config_with_basis = MOIT.TestConfig(basis = true)
+
+@testset "GreaterToLess" begin
+    bridged_mock = MOIB.GreaterToLess{Float64}(mock)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 0]),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0]),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, -100]))
+    MOIT.linear6test(bridged_mock, config)
+
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}}()))
+    test_delete_bridge(bridged_mock, ci, 2,
+                       ((MOI.ScalarAffineFunction{Float64},
+                         MOI.LessThan{Float64}, 1),))
+end
+
+@testset "LessToGreater" begin
+    bridged_mock = MOIB.LessToGreater{Float64}(mock)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock,
+            MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [1.0]),
+            MOI.FEASIBLE_POINT,
+                (MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}) => [1.0]
+        ),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock,
+            MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [2.0]),
+            MOI.FEASIBLE_POINT,
+                (MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}) => [1.0]
+        )
+    )
+    MOIT.solve_set_scalaraffine_lessthan(bridged_mock, config)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock,
+            MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [1.0]),
+            MOI.FEASIBLE_POINT,
+                (MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}) => [1.0]
+        ),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock,
+            MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [0.5]),
+            MOI.FEASIBLE_POINT,
+                (MOI.ScalarAffineFunction{Float64}, MOI.GreaterThan{Float64}) => [0.5]
+        )
+    )
+    MOIT.solve_coef_scalaraffine_lessthan(bridged_mock, config)
+
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64}}()))
+    test_delete_bridge(bridged_mock, ci, 1,
+                       ((MOI.ScalarAffineFunction{Float64},
+                         MOI.GreaterThan{Float64}, 0),))
+end
+
+@testset "NonnegToNonpos" begin
+    bridged_mock = MOIB.NonnegToNonpos{Float64}(mock)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 0]),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0]),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, -100]))
+    MOIT.linear7test(bridged_mock, config)
+
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.Nonnegatives}()))
+    test_delete_bridge(bridged_mock, ci, 2,
+                       ((MOI.VectorAffineFunction{Float64},
+                         MOI.Nonpositives, 1),))
+end
+
+@testset "NonposToNonneg" begin
+    bridged_mock = MOIB.NonposToNonneg{Float64}(mock)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 0]),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, 0]),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [100, -100]))
+    MOIT.linear7test(bridged_mock, config)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock,
+            MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [0.0, 0.0])
+        ),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock,
+            MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [1.0, 0.75])
+        )
+    )
+    MOIT.solve_const_vectoraffine_nonpos(bridged_mock, config)
+
+    MOIU.set_mock_optimize!(mock,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(
+            mock, MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [0.5])
+        ),
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(
+            mock, MOI.OPTIMAL, (MOI.FEASIBLE_POINT, [0.25])
+        )
+    )
+    MOIT.solve_multirow_vectoraffine_nonpos(bridged_mock, config)
+
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.Nonpositives}()))
+    test_delete_bridge(bridged_mock, ci, 1,
+                       ((MOI.VectorAffineFunction{Float64},
+                         MOI.Nonnegatives, 0),))
+end