Refactor tests 1

Author: tmigot

Project.toml

@@ -21,9 +21,10 @@ julia = "1.6"
 
 [extras]
 ADNLPModels = "54578032-b7ea-4c30-94aa-7cbd1cce6c9a"
+Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6"
 NLPModelsJuMP = "792afdf1-32c1-5681-94e0-d7bf7a5df49e"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["ADNLPModels", "NLPModels", "NLPModelsJuMP", "Test"]
+test = ["ADNLPModels", "Distributed", "NLPModels", "NLPModelsJuMP", "Test"]

script_get_modified.jl

@@ -0,0 +1,34 @@
+using OptimizationProblems, Random
+
+Random.seed!(1234)
+n_lim = 200
+
+names_pb_vars = OptimizationProblems.meta[
+    OptimizationProblems.meta.variable_nvar .== true,
+    [:name]
+]
+list_of_changing_variables = String[]
+for prob in eachrow(names_pb_vars)
+    for i=1:n_lim
+        n_calc = OptimizationProblems.eval(Symbol(:get_, prob[:name], :_nvar))(n = i)
+        if n_calc != i
+            push!(list_of_changing_variables, prob[:name])
+            break
+        end
+    end
+end
+
+
+#=
+julia> print(list_of_changing_variables)
+["NZF1", "bearing", "broydn7d", "catenary", "chain", "chainwoo", "channel", "clnlbeam", "clplatea", "clplateb", "clplatec", "controlinvestment", "dixmaane", "dixmaanf", "dixmaang", "dixmaanh", "dixmaani", "dixmaanj", "dixmaank", "dixmaanl", "dixmaanm", "dixmaann", "dixmaano", "dixmaanp", "elec", "hovercraft1d", "marine", "polygon", "polygon1", "polygon2", "polygon3", "powellsg", "robotarm", "spmsrtls", "structural", "woods"]
+=#
+
+nlp = OptimizationProblems.ADNLPProblems.bt1()
+function check_obj_allocs(; nlp = nlp)
+    x = zeros(2)
+    obj(nlp, x)
+    return nothing
+end
+@allocated check_obj_allocs()
+@allocated check_obj_allocs()

test/runtests.jl

@@ -1,20 +1,36 @@
-using NLPModels, NLPModelsJuMP, OptimizationProblems, Test
+using Distributed
+
+np = Sys.CPU_THREADS
+addprocs(np - 1)
+
+@everywhere using NLPModels, NLPModelsJuMP, OptimizationProblems, Test
 
 @test names(ADNLPProblems) == [:ADNLPProblems]
 
-import ADNLPModels
+@everywhere import ADNLPModels
 
 const list_problems = intersect(names(ADNLPProblems), names(PureJuMP))
-# all problems have a JuMP and ADNLPModels formulations
-@test setdiff(union(names(ADNLPProblems), names(PureJuMP)), list_problems) ==
-      [:ADNLPProblems, :PureJuMP]
+
+# The problems included should be carefully argumented and issues
+# to create them added.
+# TODO: tests are limited for JuMP-only problems
+const list_problems_not_ADNLPProblems = Symbol[]
+const list_problems_not_PureJuMP = Symbol[]
+
+const list_problems_ADNLPProblems = setdiff(list_problems, list_problems_not_ADNLPProblems)
+const list_problems_PureJuMP = setdiff(list_problems, list_problems_not_PureJuMP)
+
+@test setdiff(union(names(ADNLPProblems), list_problems_not_ADNLPProblems), list_problems) ==
+      [:ADNLPProblems]
+@test setdiff(union(names(PureJuMP), list_problems_not_PureJuMP), list_problems) ==
+      [:PureJuMP]
 
 include("test_utils.jl")
 
 @test ndef == OptimizationProblems.PureJuMP.default_nvar
 @test ndef == OptimizationProblems.ADNLPProblems.default_nvar
 
-@testset "problem: $prob" for prob in list_problems
+@everywhere function test_one_problem(prob::Symbol)
   pb = string(prob)
 
   nvar = OptimizationProblems.eval(Symbol(:get_, prob, :_nvar))()
@@ -52,14 +68,18 @@ include("test_utils.jl")
     end
   end
 
-  @testset "Test problems compatibility for $prob" begin
-    prob_fn = eval(Meta.parse("PureJuMP.$(prob)"))
-    model = prob_fn(n = ndef)
-    nlp_jump = MathOptNLPModel(model)
-    test_compatibility(prob, nlp_jump, nlp_ad, ndef)
+  if prob in list_problems_PureJuMP
+    @testset "Test problems compatibility for $prob" begin
+      prob_fn = eval(Meta.parse("PureJuMP.$(prob)"))
+      model = prob_fn(n = ndef)
+      nlp_jump = MathOptNLPModel(model)
+      test_compatibility(prob, nlp_jump, nlp_ad, ndef)
+    end
   end
 end
 
+pmap(test_one_problem, list_problems_ADNLPProblems[1:10])
+
 names_pb_vars = meta[
   meta.variable_nvar .== true,
   [:nvar, :name, :best_known_upper_bound, :best_known_lower_bound],
@@ -84,3 +104,5 @@ adproblems11 = (
     @test n11 != pb[:nvar]
   end
 end
+
+rmprocs()

test/test_utils.jl

@@ -1,13 +1,11 @@
-ndef = OptimizationProblems.default_nvar
-test_nvar = Int(round(ndef / 2))
+const ndef = OptimizationProblems.default_nvar
+const test_nvar = Int(round(ndef / 2))
 meta = OptimizationProblems.meta
 
 # Avoid SparseADJacobian/Hessian for too large problem as it requires a lot of memory for CIs
-simp_backend = "jacobian_backend = ADNLPModels.ForwardDiffADJacobian, hessian_backend = ADNLPModels.ForwardDiffADHessian"
+const simp_backend = "jacobian_backend = ADNLPModels.ForwardDiffADJacobian, hessian_backend = ADNLPModels.ForwardDiffADHessian"
 
-# list of functions used in unit tests
-
-function meta_sanity_check(prob::Symbol, nlp::AbstractNLPModel)
+@everywhere function meta_sanity_check(prob::Symbol, nlp::AbstractNLPModel)
   meta = OptimizationProblems.eval(Symbol(prob, :_meta))
   getnvar = OptimizationProblems.eval(Symbol(:get_, prob, :_nvar))(n = test_nvar)
   @test getnvar == meta[:nvar] || meta[:variable_nvar]
@@ -29,12 +27,12 @@ function meta_sanity_check(prob::Symbol, nlp::AbstractNLPModel)
   @test meta[:has_fixed_variables] == (get_ifix(nlp) != [])
 end
 
-function test_in_place_constraints(prob::Symbol)
+@everywhere function test_in_place_constraints(prob::Symbol)
   nlp = OptimizationProblems.ADNLPProblems.eval(prob)()
   return test_in_place_constraints(prob, nlp)
 end
 
-function test_in_place_constraints(prob::Symbol, nlp::AbstractNLPModel)
+@everywhere function test_in_place_constraints(prob::Symbol, nlp::AbstractNLPModel)
   x = get_x0(nlp)
   ncon = nlp.meta.nnln
   @test ncon > 0
@@ -47,13 +45,13 @@ function test_in_place_constraints(prob::Symbol, nlp::AbstractNLPModel)
   @test ncon == m
 end
 
-function test_in_place_residual(prob::Symbol)
+@everywhere function test_in_place_residual(prob::Symbol)
   nls = OptimizationProblems.ADNLPProblems.eval(prob)(use_nls = true)
   @test typeof(nls) <: ADNLPModels.ADNLSModel
   return test_in_place_residual(prob, nls)
 end
 
-function test_in_place_residual(prob::Symbol, nls::AbstractNLSModel)
+@everywhere function test_in_place_residual(prob::Symbol, nls::AbstractNLSModel)
   x = nls.meta.x0
   Fx = similar(x, nls.nls_meta.nequ)
   pb = String(prob)
@@ -65,7 +63,7 @@ function test_in_place_residual(prob::Symbol, nls::AbstractNLSModel)
   @test nls.nls_meta.nequ == m
 end
 
-function test_compatibility(prob::Symbol, ndef::Integer = ndef)
+@everywhere function test_compatibility(prob::Symbol, ndef::Integer = ndef)
   prob_fn = eval(Meta.parse("PureJuMP.$(prob)"))
   model = prob_fn(n = ndef)
   nlp_jump = MathOptNLPModel(model)
@@ -83,7 +81,7 @@ function test_compatibility(prob::Symbol, ndef::Integer = ndef)
   return test_compatibility(prob, nlp_jump, nlp_ad, ndef)
 end
 
-function test_compatibility(
+@everywhere function test_compatibility(
   prob::Symbol,
   nlp_jump,
   nlp_ad::ADNLPModels.ADModel,
@@ -126,7 +124,7 @@ function test_compatibility(
   meta_sanity_check(prob, nlp_ad)
 end
 
-function test_multi_precision(
+@everywhere function test_multi_precision(
   prob::Symbol,
   nlp_ad::ADNLPModels.ADNLPModel{T};
   list_types = [Float32, Float64],
@@ -135,7 +133,7 @@ function test_multi_precision(
   test_multi_precision(prob, list_types = setdiff(list_types, [T]))
 end
 
-function test_multi_precision(prob::Symbol; list_types = [Float32, Float64])
+@everywhere function test_multi_precision(prob::Symbol; list_types = [Float32, Float64])
   nvar = OptimizationProblems.eval(Symbol(:get_, prob, :_nvar))()
   ncon = OptimizationProblems.eval(Symbol(:get_, prob, :_ncon))()
 
@@ -149,7 +147,7 @@ function test_multi_precision(prob::Symbol; list_types = [Float32, Float64])
   end
 end
 
-function test_multi_precision(::Type{T}, nlp::AbstractNLPModel) where {T}
+@everywhere function test_multi_precision(::Type{T}, nlp::AbstractNLPModel) where {T}
   x0 = get_x0(nlp)
   @test eltype(x0) == T
   @test typeof(obj(nlp, x0)) == T