fixed tests for latest JuMP/MOI versions

Author: Wikunia

CHANGELOG.md

@@ -1,5 +1,8 @@
 # ConstrainSolver.jl - Changelog
 
+## v0.3.1
+- Added `copy` function for constraint structs for latest JuMP/MOI versions
+
 ## v0.3.0
 - Reified constraint [#171](https://github.com/Wikunia/ConstraintSolver.jl/pull/171)
 

Project.toml

@@ -1,7 +1,7 @@
 name = "ConstraintSolver"
 uuid = "e0e52ebd-5523-408d-9ca3-7641f1cd1405"
 authors = ["Ole Kröger <[email protected]>"]
-version = "0.3.0"
+version = "0.3.1"
 
 [deps]
 Formatting = "59287772-0a20-5a39-b81b-1366585eb4c0"

src/types.jl

@@ -46,14 +46,16 @@ end
 =================== SETS FOR VARIABLES AND CONSTRAINTS ==============================
 ====================================================================================#
 
-struct Integers <: MOI.AbstractScalarSet 
+struct Integers <: MOI.AbstractScalarSet
     values::Vector{Int}
 end
 Integers(vals::Union{UnitRange{Int}, StepRange{Int, Int}}) = Integers(collect(vals))
+Base.copy(I::Integers) = Integers(I.values)
 
 struct AllDifferentSetInternal <: MOI.AbstractVectorSet
     dimension :: Int
 end
+Base.copy(A::AllDifferentSetInternal) = AllDifferentSetInternal(A.dimension)
 
 struct AllDifferentSet <: JuMP.AbstractVectorSet end
 JuMP.moi_set(::AllDifferentSet, dim) = AllDifferentSetInternal(dim)
@@ -62,22 +64,25 @@ struct TableSetInternal <: MOI.AbstractVectorSet
     dimension :: Int
     table     :: Array{Int, 2}
 end
+Base.copy(T::TableSetInternal) = TableSetInternal(T.dimension, T.table)
 
-struct TableSet <: JuMP.AbstractVectorSet 
+struct TableSet <: JuMP.AbstractVectorSet
     table     :: Array{Int, 2}
 end
 JuMP.moi_set(ts::TableSet, dim) = TableSetInternal(dim, ts.table)
 
 struct EqualSetInternal <: MOI.AbstractVectorSet
     dimension::Int
 end
+Base.copy(E::EqualSetInternal) = EqualSetInternal(E.dimension)
 
 struct EqualSet <: JuMP.AbstractVectorSet end
 JuMP.moi_set(::EqualSet, dim) = EqualSetInternal(dim)
 
 struct NotEqualTo{T} <: MOI.AbstractScalarSet
     value::T
 end
+Base.copy(N::NotEqualTo) = NotEqualTo(N.value)
 
 #====================================================================================
 ====================== TYPES FOR CONSTRAINTS ========================================
@@ -86,7 +91,7 @@ end
 abstract type Constraint end
 
 """
-    BoundRhsVariable 
+    BoundRhsVariable
 idx - variable index in the lp Model
 lb  - lower bound of that variable
 ub  - upper bound of that variable
@@ -110,10 +115,10 @@ mutable struct MatchingInit
 end
 
 """
-    RSparseBitSet  
+    RSparseBitSet
 
 See https://arxiv.org/pdf/1604.06641.pdf
-words[x] will save 64 possibilities in a TableConstraint a `1` at position y will mean that the 
+words[x] will save 64 possibilities in a TableConstraint a `1` at position y will mean that the
 words in row (x-1)*64+y of the table are possible a 0 means that they aren't
 Similar to `Variable` a whole block of 64 rows can be removed by changing the `indices` and `last_ptr`.
 The `mask` saves the current mask to change words
@@ -123,21 +128,21 @@ mutable struct RSparseBitSet
     indices   :: Vector{Int}
     last_ptr  :: Int
     mask      :: Vector{UInt64}
-    RSparseBitSet() = new() 
+    RSparseBitSet() = new()
 end
 
 mutable struct TableSupport
-    # defines the range for each variable 
+    # defines the range for each variable
     # i.e [1,3,7,10] means that the first variable has 2 values, the second 4
-    var_start   :: Vector{Int} 
+    var_start   :: Vector{Int}
     values      :: Array{UInt64, 2}
     TableSupport() = new()
 end
 
 mutable struct TableResidues
-    # defines the range for each variable 
+    # defines the range for each variable
     # i.e [1,3,7,10] means that the first variable has 2 values, the second 4
-    var_start   :: Vector{Int} 
+    var_start   :: Vector{Int}
     values      :: Vector{Int}
     TableResidues() = new()
 end
@@ -153,18 +158,20 @@ struct IndicatorSet{A} <: MOI.AbstractVectorSet
     set     :: MOI.AbstractVectorSet
     dimension::Int
 end
+Base.copy(I::IndicatorSet{A}) where A = IndicatorSet{A}(I.func, I.set, I.dimension)
 
 struct ReifiedSet{A} <: MOI.AbstractVectorSet
     func    :: Union{JuMP.GenericAffExpr, MOI.VectorOfVariables}
     set     :: Union{MOI.AbstractScalarSet, MOI.AbstractVectorSet}
     dimension::Int
 end
+Base.copy(R::ReifiedSet{A}) where A = ReifiedSet{A}(R.func, R.set, R.dimension)
 
 #====================================================================================
 ====================================================================================#
 
 mutable struct ImplementedConstraintFunctions
-    init :: Bool 
+    init :: Bool
     finished_pruning :: Bool
     restore_pruning :: Bool
     single_reverse_pruning :: Bool
@@ -233,7 +240,7 @@ mutable struct TableConstraint <: Constraint
     supports::TableSupport
     last_sizes::Vector{Int}
     residues::TableResidues
-    # holds current, last_ptr and indices from each node 
+    # holds current, last_ptr and indices from each node
     # maybe it's better to compute some of them to save some space...
     # This is the easy implementation first
     backtrack::Vector{TableBacktrackInfo}

test/killer_sudoku.jl

@@ -124,18 +124,19 @@ end
         end
         com = JuMP.backend(m).optimizer.model.inner
         @test general_tree_test(com)
-       
+
         return com
     end
 
     @testset "Killer Sudoku niallsudoku_5503 with negative coefficients and -9 to -1" begin
         com1 = killer_negative()
-        @test_reference "refs/niallsudoku_5503_negative" test_string([constraint.indices for constraint in com1.constraints])
+        com1_str = test_string([constraint.indices for constraint in com1.constraints])
         # the constraint order now affects this but calling the same twice should have the same ordering
         # this tests that the order of constraints the user specified is actually moved correctly to ConstraintSolver instead of being random
         # see https://github.com/Wikunia/ConstraintSolver.jl/issues/180
         com2 = killer_negative()
-        @test_reference "refs/niallsudoku_5503_negative" test_string([constraint.indices for constraint in com2.constraints])
+        com2_str = test_string([constraint.indices for constraint in com2.constraints])
+        @test com1_str == com2_str
         info_1 = com1.info
         info_2 = com2.info
         @test info_1.pre_backtrack_calls == info_2.pre_backtrack_calls

test/lp_solver.jl

@@ -1,6 +1,6 @@
 @testset "LP Solver" begin
     @testset "Issue 83 TimeLimit" begin
-        glpk_optimizer = optimizer_with_attributes(GLPK.Optimizer, "msg_lev" => GLPK.OFF)
+        glpk_optimizer = optimizer_with_attributes(GLPK.Optimizer, "msg_lev" => GLPK.GLP_OFF)
         model = Model(optimizer_with_attributes(
             CS.Optimizer,
             "lp_optimizer" => glpk_optimizer,
@@ -40,7 +40,7 @@
 
 
     @testset "Issue 83 max_bt_steps" begin
-        glpk_optimizer = optimizer_with_attributes(GLPK.Optimizer, "msg_lev" => GLPK.OFF)
+        glpk_optimizer = optimizer_with_attributes(GLPK.Optimizer, "msg_lev" => GLPK.GLP_OFF)
         model = Model(optimizer_with_attributes(
             CS.Optimizer,
             "lp_optimizer" => glpk_optimizer,
@@ -77,7 +77,7 @@
 
 
     @testset "Issue 83" begin
-        glpk_optimizer = optimizer_with_attributes(GLPK.Optimizer, "msg_lev" => GLPK.OFF)
+        glpk_optimizer = optimizer_with_attributes(GLPK.Optimizer, "msg_lev" => GLPK.GLP_OFF)
         model = Model(optimizer_with_attributes(
             CS.Optimizer,
             "lp_optimizer" => glpk_optimizer,
@@ -123,11 +123,11 @@
 
         # Variables
         @variable(model, 1 <= x[1:10] <= 15, Int)
-        
+
         # Constraints
         @constraint(model, sum(x[1:5]) >= 10)
         @constraint(model, sum(x[6:10]) <= 15)
-    
+
         table_left = [
             1 2 3 4 5; # sum 16
             1 2 3 4 6; #     17
@@ -142,7 +142,7 @@
 
         @constraint(model, x[1:5] in CS.TableSet(table_left))
         @constraint(model, x[6:10] in CS.TableSet(table_right))
-    
+
         @objective(model, Max, sum(x))
         optimize!(model)
 
@@ -162,7 +162,7 @@
 
         # Variables
         @variable(model, 1 <= x[1:10] <= 15, Int)
-        
+
         # Constraints
         @constraint(model, sum(x[1:4]) >= 10)
         @constraint(model, sum(x[5:10]) <= 15)
@@ -219,7 +219,7 @@
         @objective(model, Max, sum(x))
         optimize!(model)
         # possible solution 11+12+13+14+15  + 1+2+3+4+5
-        # only works fast if the all different bound works 
+        # only works fast if the all different bound works
         @test JuMP.objective_value(model) ≈ 80
         @test sum(JuMP.value.(x[6:10])) ≈ 15
         @test !(1.5*JuMP.value(x[1]) + 2*JuMP.value(x[2]) ≈ 40.5)
@@ -238,18 +238,18 @@
 
         # Variables
         @variable(model, 1 <= x[1:10] <= 15, Int)
-        
+
         # Constraints
         @constraint(model, sum(x[1:5]) >= 10)
         @constraint(model, sum(x[6:10]) <= 15)
         # disallow x[1] = 11 and x[2] == 12
         @constraint(model, 1.5*x[1]+2*x[2] != 40.5)
         @constraint(model, x in CS.AllDifferentSet())
-       
+
         @objective(model, Max, sum(x))
         optimize!(model)
         # possible solution 11+12+13+14+15  + 1+2+3+4+5
-        # only works fast if the all different bound works 
+        # only works fast if the all different bound works
         @test JuMP.objective_value(model) ≈ 80
         @test sum(JuMP.value.(x[6:10])) ≈ 15
         @test !(1.5*JuMP.value(x[1]) + 2*JuMP.value(x[2]) ≈ 40.5)
@@ -271,18 +271,18 @@
 
         # Variables
         @variable(model, 1 <= x[1:10] <= 15, Int)
-        
+
         # Constraints
         @constraint(model, sum(x[1:5]) >= 10)
         @constraint(model, sum(x[6:10]) <= 15)
         # disallow x[1] = 11 and x[2] == 12
         @constraint(model, 1.5*x[1]+2*x[2] != 40.5)
         @constraint(model, x in CS.AllDifferentSet())
-       
+
         @objective(model, Max, sum(x))
         optimize!(model)
         # possible solution 11+12+13+14+15  + 1+2+3+4+5
-        # only works fast if the all different bound works 
+        # only works fast if the all different bound works
         @test JuMP.objective_value(model) ≈ 80
         @test sum(JuMP.value.(x[6:10])) ≈ 15
         @test !(1.5*JuMP.value(x[1]) + 2*JuMP.value(x[2]) ≈ 40.5)

test/runtests.jl

@@ -22,7 +22,7 @@ end
 """
     test_string(arr::AbstractArray)
 
-In Julia 1.0 string(arr) starts with Array{Int, 1} or something. In 1.5 it doesn't. 
+In Julia 1.0 string(arr) starts with Array{Int, 1} or something. In 1.5 it doesn't.
 This function removes Array{...} and starts with `[`. Additionally all white spaces are removed.
 """
 function test_string(arr::AbstractArray)