diff --git a/Project.toml b/Project.toml
index c180e88..de07e5a 100644
--- a/Project.toml
+++ b/Project.toml
@@ -7,13 +7,5 @@ version = "0.6.5"
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
 
 [compat]
-JuMP = "~0.21.1"
-MathOptInterface = "~0.9.5"
-julia = "1"
-
-[extras]
-JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-
-[targets]
-test = ["JuMP", "Test"]
+MathOptInterface = "0.10.9"
+julia = "1.6"
diff --git a/src/BARON.jl b/src/BARON.jl
index b10e201..376861c 100644
--- a/src/BARON.jl
+++ b/src/BARON.jl
@@ -42,6 +42,7 @@ end
     SYNTAX_ERROR = 10
     LICENSING_ERROR = 11
     USER_HEURISTIC_TERMINATION = 12
+    CALL_TO_EXEC_FAILED = 99 # TODO allow reach here
 end
 
 @enum BaronModelStatus begin
@@ -79,6 +80,8 @@ mutable struct BaronModel
 
     solution_info::Union{Nothing, SolutionStatus}
 
+    print_input_file::Bool
+
     function BaronModel(; kwargs...)
         options = Dict{String, Any}(string(key) => val for (key,val) in kwargs)
         model = new()
@@ -94,6 +97,7 @@ mutable struct BaronModel
         model.summary_file_name = get!(options, "SumName", joinpath(temp_dir, "sum.lst"))
         model.result_file_name = get!(options, "ResName", joinpath(temp_dir, "res.lst"))
         model.solution_info = nothing
+        model.print_input_file = false
         return model
     end
 end
diff --git a/src/MOI_wrapper.jl b/src/MOI_wrapper.jl
index f1cec18..76a6623 100644
--- a/src/MOI_wrapper.jl
+++ b/src/MOI_wrapper.jl
@@ -9,7 +9,6 @@ const VI = MOI.VariableIndex
 const CI = MOI.ConstraintIndex
 
 # function aliases
-const SV = MOI.SingleVariable
 const SAF = MOI.ScalarAffineFunction{Float64}
 const SQF = MOI.ScalarQuadraticFunction{Float64}
 
@@ -42,9 +41,10 @@ function MOI.empty!(model::Optimizer)
 end
 
 # copy
-MOIU.supports_default_copy_to(model::Optimizer, copy_names::Bool) = !copy_names
+# MOIU.supports_default_copy_to(::Optimizer, copy_names::Bool) = !copy_names
+MOI.supports_incremental_interface(::Optimizer) = true
 function MOI.copy_to(dest::Optimizer, src::MOI.ModelLike; kws...)
-    return MOIU.automatic_copy_to(dest, src; kws...)
+    return MOIU.default_copy_to(dest, src; kws...)
 end
 
 # optimize
@@ -54,17 +54,27 @@ function MOI.optimize!(model::Optimizer)
                  Set the environment variable `BARON_EXEC` and run `using Pkg; Pkg.build("BARON")`."""))
     end
     write_bar_file(model.inner)
-    run(`$baron_exec $(model.inner.problem_file_name)`)
+    if model.inner.print_input_file
+        println("\nBARON input file: $(model.inner.problem_file_name)\n")
+        println(read(model.inner.problem_file_name, String))
+    end
+    try
+        run(`$baron_exec $(model.inner.problem_file_name)`)
+    catch e
+        println("$e")
+        println(read(model.inner.problem_file_name, String))
+        error("failed to call BARON exec $baron_exec")
+    end
     read_results(model.inner)
 end
 
-# RawParameter
-MOI.supports(::Optimizer, ::MOI.RawParameter) = true
-function MOI.set(model::Optimizer, param::MOI.RawParameter, value)
+# RawOptimizerAttribute
+MOI.supports(::Optimizer, ::MOI.RawOptimizerAttribute) = true
+function MOI.set(model::Optimizer, param::MOI.RawOptimizerAttribute, value)
     model.inner.options[param.name] = value
     return
 end
-function MOI.get(model::Optimizer, param::MOI.RawParameter)
+function MOI.get(model::Optimizer, param::MOI.RawOptimizerAttribute)
     return get(model.inner.options, param.name) do
         throw(ErrorException("Requested parameter $(param.name) is not set."))
     end
@@ -82,6 +92,15 @@ function MOI.get(model::Optimizer, ::MOI.TimeLimitSec)
     return get(model.inner.options, "MaxTime", 1000.0)
 end
 
+struct PrintInputFile <: MOI.AbstractOptimizerAttribute end
+function MOI.set(model::Optimizer, ::PrintInputFile, val::Bool)
+    model.inner.print_input_file = val
+    return
+end
+function MOI.get(model::Optimizer, ::PrintInputFile)
+    model.inner.print_input_file
+end
+
 include(joinpath("moi", "util.jl"))
 include(joinpath("moi", "variables.jl"))
 include(joinpath("moi", "constraints.jl"))
diff --git a/src/moi/constraints.jl b/src/moi/constraints.jl
index 4ce434a..a3dd101 100644
--- a/src/moi/constraints.jl
+++ b/src/moi/constraints.jl
@@ -16,17 +16,17 @@ function set_bounds(info::Union{VariableInfo, ConstraintInfo}, set::MOI.Interval
     set_upper_bound(info, set.upper)
 end
 
-MOI.supports_constraint(::Optimizer, ::Type{SV}, ::Type{<:Bounds}) = true
+MOI.supports_constraint(::Optimizer, ::Type{MOI.VariableIndex}, ::Type{<:Bounds{Float64}}) = true
 
-function MOI.add_constraint(model::Optimizer, f::SV, set::S) where {S <: Bounds}
-    variable_info = find_variable_info(model, f.variable)
+function MOI.add_constraint(model::Optimizer, f::MOI.VariableIndex, set::S) where {S <: Bounds{Float64}}
+    variable_info = find_variable_info(model, f)
     set_bounds(variable_info, set)
-    return CI{SV, S}(f.variable.value)
+    return CI{MOI.VariableIndex, S}(f.value)
 end
 
-MOI.supports_constraint(::Optimizer, ::Type{<:Union{SAF, SQF}}, ::Type{<:Bounds}) = true
+MOI.supports_constraint(::Optimizer, ::Type{<:Union{SAF, SQF}}, ::Type{<:Bounds{Float64}}) = true
 
-function MOI.add_constraint(model::Optimizer, f::F, set::S) where {F <: Union{SAF, SQF}, S <: Bounds}
+function MOI.add_constraint(model::Optimizer, f::F, set::S) where {F <: Union{SAF, SQF}, S <: Bounds{Float64}}
     ci = ConstraintInfo()
     ci.expression = to_expr(f)
     set_bounds(ci, set)
@@ -34,33 +34,33 @@ function MOI.add_constraint(model::Optimizer, f::F, set::S) where {F <: Union{SA
     return CI{F, S}(length(model.inner.constraint_info))
 end
 
-MOI.supports(::Optimizer, ::MOI.ConstraintName, ::Type{CI}) = true
-
-function MOI.set(model::Optimizer, attr::MOI.ConstraintName, ci::CI{SV}, value)
-    error("No support for naming constraints imposed on variables.")
-end
-function MOI.set(model::Optimizer, attr::MOI.ConstraintName, ci::CI, value)
-    check_constraint_indices(model, ci)
-    model.inner.constraint_info[ci.value].name = value
-end
-function MOI.get(model::Optimizer, ::MOI.ConstraintName, ci::CI)
-     return model.inner.constraint_info[ci.value].name
-end
-
-function MOI.get(model::Optimizer, ::Type{MathOptInterface.ConstraintIndex}, name::String)
-    for (i,c) in enumerate(model.inner.constraint_info)
-        if name == c.name
-            return CI(i)
-        end
-    end
-    error("Unrecognized constraint name $name.")
-end
+# see comment in: write_bar_file
+# MOI.supports(::Optimizer, ::MOI.ConstraintName, ::Type{CI}) = true
+# function MOI.set(model::Optimizer, attr::MOI.ConstraintName, ci::CI{MOI.VariableIndex}, value)
+#     error("No support for naming constraints imposed on variables.")
+# end
+# function MOI.set(model::Optimizer, attr::MOI.ConstraintName, ci::CI, value)
+#     check_constraint_indices(model, ci)
+#     model.inner.constraint_info[ci.value].name = value
+# end
+# function MOI.get(model::Optimizer, ::MOI.ConstraintName, ci::CI)
+#      return model.inner.constraint_info[ci.value].name
+# end
+# function MOI.get(model::Optimizer, ::Type{MathOptInterface.ConstraintIndex}, name::String)
+#     for (i,c) in enumerate(model.inner.constraint_info)
+#         if name == c.name
+#             return CI(i)
+#         end
+#     end
+#     error("Unrecognized constraint name $name.")
+# end
 
-MOI.supports_constraint(::Optimizer, ::Type{SV}, ::Type{MOI.ZeroOne}) = true
-MOI.supports_constraint(::Optimizer, ::Type{SV}, ::Type{MOI.Integer}) = true
+MOI.supports_constraint(::Optimizer, ::Type{MOI.VariableIndex}, ::Type{MOI.ZeroOne}) = true
+MOI.supports_constraint(::Optimizer, ::Type{MOI.VariableIndex}, ::Type{MOI.Integer}) = true
 
-function MOI.add_constraint(model::Optimizer, f::SV, set::S) where {S <: Union{MOI.ZeroOne, MOI.Integer}}
-    variable_info = find_variable_info(model, f.variable)
+function MOI.add_constraint(model::Optimizer, f::MOI.VariableIndex, set::S
+) where {S <: Union{MOI.ZeroOne, MOI.Integer}}
+    variable_info = find_variable_info(model, f)
     if set isa MOI.ZeroOne
         variable_info.category = :Bin
     elseif set isa MOI.Integer
@@ -68,7 +68,7 @@ function MOI.add_constraint(model::Optimizer, f::SV, set::S) where {S <: Union{M
     else
         error("Unsupported variable type $set.")
     end
-    return CI{SV, S}(f.variable.value)
+    return CI{MOI.VariableIndex, S}(f.value)
 end
 
 # MOI.supports(::Optimizer, ::MOI.NLPBlock) = true
diff --git a/src/moi/nlp.jl b/src/moi/nlp.jl
index 624c91e..a914970 100644
--- a/src/moi/nlp.jl
+++ b/src/moi/nlp.jl
@@ -23,12 +23,19 @@ function MOI.set(model::Optimizer, ::MOI.NLPBlock, nlp_data::MOI.NLPBlockData)
     MOI.initialize(nlp_eval, [:ExprGraph])
 
     if nlp_data.has_objective
-        if model.inner.objective_expr !== nothing
-            error("Two objectives set: One linear, one nonlinear.")
-        end
+        # according to test: test_nonlinear_objective_and_moi_objective_test
+        # from MOI 0.10.9, linear objectives are just ignores if the noliena exists
+        # if model.inner.objective_expr !== nothing
+            # error("Two objectives set: One linear, one nonlinear.")
+        # end
         obj = verify_support(MOI.objective_expr(nlp_eval))
         walk_and_strip_variable_index!(obj)
+
         model.inner.objective_expr = obj
+        # if obj == :NaN
+        #     model.inner.objective_expr = 0.0
+        # else
+        # end
     end
 
     for i in 1:length(nlp_data.constraint_bounds)
diff --git a/src/moi/objective.jl b/src/moi/objective.jl
index 6450dcc..96d7aa0 100644
--- a/src/moi/objective.jl
+++ b/src/moi/objective.jl
@@ -16,7 +16,7 @@ end
 MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{SAF}) = true
 MOI.supports(::Optimizer, ::MOI.ObjectiveFunction{SQF}) = true
 
-function MOI.set(model::Optimizer, ::MOI.ObjectiveFunction{F}, obj::F) where {F<:Union{SV, SAF, SQF}}
+function MOI.set(model::Optimizer, ::MOI.ObjectiveFunction{F}, obj::F) where {F<:Union{VI, SAF, SQF}}
     model.inner.objective_expr = to_expr(obj)
     return
 end
diff --git a/src/moi/results.jl b/src/moi/results.jl
index 16fa60c..dcccba4 100644
--- a/src/moi/results.jl
+++ b/src/moi/results.jl
@@ -47,7 +47,14 @@ function MOI.get(model::Optimizer, ::MOI.ResultCount)
     return (model.inner.solution_info.feasible_point === nothing) ? 0 : 1
 end
 
-function MOI.get(model::Optimizer, ::MOI.PrimalStatus)
+function MOI.get(model::Optimizer, ::MOI.DualStatus)
+    MOI.NO_SOLUTION
+end
+
+function MOI.get(model::Optimizer, attr::MOI.PrimalStatus)
+    if attr.result_index != 1
+        return MOI.NO_SOLUTION
+    end
     solution_info = model.inner.solution_info
     if solution_info === nothing || solution_info.feasible_point === nothing
         return MOI.NO_SOLUTION
@@ -56,9 +63,22 @@ function MOI.get(model::Optimizer, ::MOI.PrimalStatus)
     end
 end
 
-MOI.get(model::Optimizer, ::MOI.ObjectiveValue) = model.inner.solution_info.objective_value
+function MOI.get(model::Optimizer, attr::MOI.ObjectiveValue)
+    MOI.check_result_index_bounds(model, attr)
+    # if model.inner.solution_info.model_status == UNBOUNDED
+    #     # BARON will set the same large number
+    #     # for both abj and variables in case of unbounded
+    #     # this would make it retur MOI consistent values
+    #     # but getters are no define and NL one would be messy
+    #     return MOIU.get_fallback(model, attr)
+    # else
+        model.inner.solution_info.objective_value
+    # end
+end
 
-function MOI.get(model::Optimizer, ::MOI.VariablePrimal, vi::VI)
+function MOI.get(model::Optimizer, attr::MOI.VariablePrimal, vi::VI)
+    MOI.check_result_index_bounds(model, attr)
+    # MOI.throw_if_not_valid(model, vi) # TODO implement is_valid
     solution_info = model.inner.solution_info
     if solution_info === nothing || solution_info.feasible_point === nothing
         error("VariablePrimal not available.")
@@ -72,15 +92,21 @@ function MOI.get(model::Optimizer, ::MOI.ObjectiveBound)
     return solution_info.dual_bound
 end
 
-function MOI.get(model::Optimizer, ::MOI.SolveTime)
+function MOI.get(model::Optimizer, ::MOI.SolveTimeSec)
     solution_info = model.inner.solution_info
     return solution_info.wall_time
 end
 
+function MOI.get(model::Optimizer, ::MOI.RawStatusString)
+    info = model.inner.solution_info
+    return "solver: $(info.solver_status), model: $(info.model_status)"
+end
 
 # TODO: desirable?
 function MOI.get(model::MOIU.CachingOptimizer{BARON.Optimizer}, attr::MOI.ConstraintPrimal, ci::MOI.ConstraintIndex)
     return MOIU.get_fallback(model, attr, ci)
 end
 
-# TODO: MOI getter for solvetime
+function MOI.supports(::Optimizer, ::MOI.SolverVersion)
+    false
+end
\ No newline at end of file
diff --git a/src/moi/util.jl b/src/moi/util.jl
index 48aa17d..d4c514b 100644
--- a/src/moi/util.jl
+++ b/src/moi/util.jl
@@ -1,5 +1,5 @@
 # to_expr
-to_expr(sv::SV) = :(x[$(sv.variable.value)])
+to_expr(vi::MOI.VariableIndex) = :(x[$(vi.value)])
 
 function to_expr(f::SAF)
     f = MOIU.canonical(f)
@@ -7,7 +7,7 @@ function to_expr(f::SAF)
         return f.constant
     else
         linear_term_exprs = map(f.terms) do term
-            :($(term.coefficient) * x[$(term.variable_index.value)])
+            :($(term.coefficient) * x[$(term.variable.value)])
         end
         expr = :(+($(linear_term_exprs...)))
         if !iszero(f.constant)
@@ -20,12 +20,12 @@ end
 function to_expr(f::SQF)
     f = MOIU.canonical(f)
     linear_term_exprs = map(f.affine_terms) do term
-        i = term.variable_index.value
+        i = term.variable.value
         :($(term.coefficient) * x[$i])
     end
     quadratic_term_exprs = map(f.quadratic_terms) do term
-        i = term.variable_index_1.value
-        j = term.variable_index_2.value
+        i = term.variable_1.value
+        j = term.variable_2.value
         if i == j
             :($(term.coefficient / 2) * x[$i] * x[$j])
         else
@@ -46,17 +46,17 @@ end
 
 function check_variable_indices(model::Optimizer, f::SAF)
     for term in f.terms
-        check_variable_indices(model, term.variable_index)
+        check_variable_indices(model, term.variable)
     end
 end
 
 function check_variable_indices(model::Optimizer, f::SQF)
     for term in f.affine_terms
-        check_variable_indices(model, term.variable_index)
+        check_variable_indices(model, term.variable)
     end
     for term in f.quadratic_terms
-        check_variable_indices(model, term.variable_index_1)
-        check_variable_indices(model, term.variable_index_2)
+        check_variable_indices(model, term.variable_1)
+        check_variable_indices(model, term.variable_2)
     end
 end
 
@@ -65,7 +65,7 @@ function find_variable_info(model::Optimizer, vi::VI)
     model.inner.variable_info[vi.value]
 end
 
-function check_constraint_indices(model::Optimizer, index::CI{SV})
+function check_constraint_indices(model::Optimizer, index::CI{MOI.VariableIndex})
     @assert 1 <= index.value <= length(model.inner.variable_info)
 end
 
diff --git a/src/moi/variables.jl b/src/moi/variables.jl
index 59d1bb3..c5a3712 100644
--- a/src/moi/variables.jl
+++ b/src/moi/variables.jl
@@ -10,46 +10,42 @@ function MOI.add_variables(model::Optimizer, nvars::Integer)
     return [MOI.add_variable(model) for i in 1:nvars]
 end
 
-function MOI.add_constraint(model::Optimizer, v::SV, lt::MOI.LessThan{Float64})
-    vi = v.variable
+function MOI.add_constraint(model::Optimizer, vi::MOI.VariableIndex, lt::MOI.LessThan{Float64})
     check_variable_indices(model, vi)
     set_upper_bound(model.inner.variable_info[vi.value], lt.upper)
-    return MOI.ConstraintIndex{SV,MOI.LessThan{Float64}}(vi.value)
+    return MOI.ConstraintIndex{MOI.VariableIndex,MOI.LessThan{Float64}}(vi.value)
 end
 
-function MOI.add_constraint(model::Optimizer, v::SV, gt::MOI.GreaterThan{Float64})
-    vi = v.variable
+function MOI.add_constraint(model::Optimizer, vi::MOI.VariableIndex, gt::MOI.GreaterThan{Float64})
     check_variable_indices(model, vi)
     set_lower_bound(model.inner.variable_info[vi.value], gt.lower)
-    return MOI.ConstraintIndex{SV, MOI.GreaterThan{Float64}}(vi.value)
+    return MOI.ConstraintIndex{MOI.VariableIndex, MOI.GreaterThan{Float64}}(vi.value)
 end
 
-function MOI.add_constraint(model::Optimizer, v::SV, eq::MOI.EqualTo{Float64})
-    vi = v.variable
+function MOI.add_constraint(model::Optimizer, vi::MOI.VariableIndex, eq::MOI.EqualTo{Float64})
     check_variable_indices(model, vi)
     set_lower_bound(model.inner.variable_info[vi.value], eq.value)
     set_upper_bound(model.inner.variable_info[vi.value], eq.value)
-    return MOI.ConstraintIndex{SV,MOI.EqualTo{Float64}}(vi.value)
-end
-
-MOI.supports(::Optimizer, ::MOI.VariableName, ::Type{VI}) = true
-
-function MOI.set(model::Optimizer, attr::MOI.VariableName, vi::VI, value)
-    check_variable_indices(model, vi)
-    model.inner.variable_info[vi.value].name = value
-end
-function MOI.get(model::Optimizer, ::MOI.VariableName, vi::VI)
-     return model.inner.variable_info[vi.value].name
-end
-
-function MOI.get(model::Optimizer, ::Type{MathOptInterface.VariableIndex}, name::String)
-    for (i,var) in enumerate(model.inner.variable_info)
-        if name == var.name
-            return VI(i)
-        end
-    end
-    error("Unrecognized variable name $name.")
-end
+    return MOI.ConstraintIndex{MOI.VariableIndex,MOI.EqualTo{Float64}}(vi.value)
+end
+
+# see comment in: write_bar_file
+# MOI.supports(::Optimizer, ::MOI.VariableName, ::Type{VI}) = true
+# function MOI.set(model::Optimizer, attr::MOI.VariableName, vi::VI, value)
+#     check_variable_indices(model, vi)
+#     model.inner.variable_info[vi.value].name = value
+# end
+# function MOI.get(model::Optimizer, ::MOI.VariableName, vi::VI)
+#      return model.inner.variable_info[vi.value].name
+# end
+# function MOI.get(model::Optimizer, ::Type{MathOptInterface.VariableIndex}, name::String)
+#     for (i,var) in enumerate(model.inner.variable_info)
+#         if name == var.name
+#             return VI(i)
+#         end
+#     end
+#     error("Unrecognized variable name $name.")
+# end
 
 MOI.supports(::Optimizer, ::MOI.VariablePrimalStart, ::Type{VI}) = true
 
diff --git a/src/util.jl b/src/util.jl
index 6492b61..e18d593 100644
--- a/src/util.jl
+++ b/src/util.jl
@@ -47,6 +47,20 @@ end
 
 verify_support(c) = c
 
+function verify_support(c::Symbol)
+    if c !== :NaN # blocks NaN and +/-Inf
+        return c
+    end
+    error("Got NaN in a constraint or objective.")
+end
+
+function verify_support(c::Real)
+    if isfinite(c) # blocks NaN and +/-Inf
+        return c
+    end
+    error("Expected number but got $c")
+end
+
 function verify_support(c::Expr)
     if c.head == :comparison
         map(verify_support, c.args)
@@ -145,6 +159,8 @@ function to_str(c::Expr)
         if c.args[1] == :x
             idx = c.args[2]
             @assert isa(idx, Int)
+            # TODO decide is use use defined names
+            # might be messy becaus a use can call his variable "sin"
             return "x$idx"
         else
             throw(UnrecognizedExpressionException("reference", c))
@@ -178,6 +194,11 @@ function write_bar_file(m::BaronModel)
         println(fp)
 
         # Print variable bounds
+        # TODO:
+        # usage of variable_info.name must be revisited
+        # now user names are disabled, but if they are enable
+        # then bounds will use these names but
+        # expressions will just use default names: "x$(variable_inde.value)"
         if any(info -> info.lower_bound !== nothing, m.variable_info)
             println(fp, "LOWER_BOUNDS{")
             for variable_info in m.variable_info
@@ -238,7 +259,13 @@ function write_bar_file(m::BaronModel)
             else
                 error("Objective sense not recognized.")
             end
-            print(fp, to_str(m.objective_expr))
+            val = to_str(m.objective_expr)
+            # might get here as: m.objective_expr = :(())
+            if val === nothing
+                print(fp, "0")
+            else
+                print(fp, val)
+            end
         end
         println(fp, ";")
         println(fp)
diff --git a/test/Project.toml b/test/Project.toml
new file mode 100644
index 0000000..1e235fe
--- /dev/null
+++ b/test/Project.toml
@@ -0,0 +1,7 @@
+[deps]
+JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
+MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[compat]
+JuMP = "0.22"
diff --git a/test/moi_test.jl b/test/moi_test.jl
index 2075b14..3033e52 100644
--- a/test/moi_test.jl
+++ b/test/moi_test.jl
@@ -5,15 +5,59 @@ using Test
 
 using MathOptInterface
 const MOI = MathOptInterface
-const MOIT = MOI.Test
+const MOIT = MOI.DeprecatedTest
 const MOIU = MOI.Utilities
 const MOIB = MOI.Bridges
 
 const optimizer = BARON.Optimizer(PrLevel=0)
-const caching_optimizer = MOIU.CachingOptimizer(MOIU.Model{Float64}(), BARON.Optimizer(PrLevel=0));
+const caching_optimizer = MOIU.CachingOptimizer(
+    MOIU.UniversalFallback(MOIU.Model{Float64}()), BARON.Optimizer(PrLevel=0));
 
+function test_runtests()
+    model = caching_optimizer#MOI.instantiate(BARON.Optimizer, with_bridge_type = Float64)
+    MOI.set(model, MOI.RawOptimizerAttribute("PrLevel"), 0)
+    # MOI.set(model, MOI.Silent(), true) # todo
+    MOI.Test.runtests(model,
+        MOI.Test.Config(
+            atol = 1e-3,
+            rtol = 1e-3,
+            # optimal_status = MOI.LOCALLY_SOLVED,
+            exclude = Any[
+                MOI.ConstraintBasisStatus,
+                MOI.DualObjectiveValue,
+                MOI.ObjectiveBound,
+                MOI.DualStatus,
+                MOI.ConstraintDual,
+            ],
+        );
+        exclude = [
+            "test_attribute_SolverVersion",      # unavailable
+            "test_nonlinear_hs071_NLPBlockDual", # MathOptInterface.NLPBlockDual(1)
+            "test_nonlinear_invalid",            # see below
+            # returns NaN in expression and solver has to responde with:
+            # MOI.get(model, MOI.TerminationStatus()) == MOI.INVALID_MODEL
+            # this code will error when NaN is found (better than waiting to knoe about bad stuff)
+            "test_variable_solve_ZeroOne_with_upper_bound",# fail is upstream
+            "test_objective_ObjectiveFunction_blank", # fail is upstream
+            "test_objective_FEASIBILITY_SENSE_clears_objective", # fail is upstream
+            "test_linear_integer_solve_twice", # simply fails in the first solve
+            # objective fails
+            # BARON will set the same large number
+            # for both abj and variables in case of unbounded
+            "test_unbounded_MIN_SENSE_offset",
+            "test_unbounded_MIN_SENSE",
+            "test_unbounded_MAX_SENSE_offset",
+            "test_unbounded_MAX_SENSE",
+        ]
+    )
+    return
+end
+@testset "New" begin
+    test_runtests()
+end
+@testset "Old" begin
 @testset "Unit" begin
-    config = MOIT.TestConfig(atol=1e-5, rtol=1e-4, infeas_certificates=true, duals=false)
+    config = MOIT.Config(atol=1e-5, rtol=1e-4, infeas_certificates=true, duals=false)
     # A number of test cases are excluded because loadfromstring! works only
     # if the solver supports variable and constraint names.
     exclude = ["delete_variable", # Deleting not supported.
@@ -58,7 +102,7 @@ end
 MOI.empty!(optimizer)
 
 @testset "MOI Continuous Linear" begin
-    config = MOIT.TestConfig(atol=1e-5, rtol=1e-4, infeas_certificates=false, duals=false)
+    config = MOIT.Config(atol=1e-5, rtol=1e-4, infeas_certificates=false, duals=false)
     excluded = String[
         "linear7", # vector constraints
         "linear8b", # certificate provided in this case (result count is 1)
@@ -68,13 +112,13 @@ MOI.empty!(optimizer)
     ]
     # MOIT.partial_start_test(optimizer, config)
     MOIT.contlineartest(caching_optimizer, config, excluded)
-    MOIT.linear8btest(caching_optimizer, MOIT.TestConfig(atol=1e-5, rtol=1e-4, infeas_certificates=true, duals=false))
+    MOIT.linear8btest(caching_optimizer, MOIT.Config(atol=1e-5, rtol=1e-4, infeas_certificates=true, duals=false))
 end
 
 MOI.empty!(optimizer)
 
 @testset "MOI Integer Linear" begin
-    config = MOIT.TestConfig(atol=1e-5, rtol=1e-4, infeas_certificates=false, duals=false)
+    config = MOIT.Config(atol=1e-5, rtol=1e-4, infeas_certificates=false, duals=false)
     excluded = String[
         "int2", # SOS1
         "int3", # SOS1
@@ -92,7 +136,7 @@ MOI.empty!(optimizer)
 
 @testset "MOI Continuous Quadratic" begin
     # TODO: rather high tolerances
-    config = MOIT.TestConfig(atol=1e-3, rtol=1e-3, infeas_certificates=false, duals=false)
+    config = MOIT.Config(atol=1e-3, rtol=1e-3, infeas_certificates=false, duals=false)
     excluded = String[
         "qcp1", # vector constraints
     ]
@@ -103,11 +147,11 @@ MOI.empty!(optimizer)
 bridged = MOIB.full_bridge_optimizer(optimizer, Float64)
 
 @testset "MOI Nonlinear" begin
-    config = MOIT.TestConfig(atol=1e-3, rtol=1e-3, infeas_certificates=false, duals=false)
+    config = MOIT.Config(atol=1e-3, rtol=1e-3, infeas_certificates=false, duals=false)
     excluded = String[
         "nlp_objective_and_moi_objective",
     ]
     MOIT.nlptest(bridged, config, excluded)
 end
-
+end#rm
 end # module