def _setUpClass(cls):
global testing_solvers
from pyomo.solvers.tests.solvers import test_solver_cases
for _solver, _io in test_solver_cases():
if (_solver, _io) in testing_solvers and \
test_solver_cases(_solver, _io).available:
testing_solvers[_solver, _io] = True
def test_scenarios(arg=None):
"""
Generate scenarios
"""
for model in sorted(test_models()):
_model = test_models(model)
if not arg is None and not arg(_model):
continue
for solver, io in sorted(test_solver_cases()):
_solver_case = test_solver_cases(solver, io)
# Skip this test case if the solver doesn't support the
# capabilities required by the model
if not _model.capabilities.issubset( _solver_case.capabilities ):
continue
# Set status values for expected failures
status='ok'
msg=""
if not _solver_case.available:
status='skip'
msg="Skipping test because solver %s (%s) is unavailable" % (solver,io)
if (solver, io, model) in ExpectedFailures:
case = ExpectedFailures[solver, io, model]
if _solver_case.version is not None and\
case[0](_solver_case.version):
status='expected failure'
msg=case[1]
# Return scenario dimensions and scenario information
yield (model, solver, io), Options(status=status, msg=msg, model=_model, solver=None, testcase=_solver_case)
def setUpModule():
global testing_solvers
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
for _solver, _io in test_solver_cases():
if (_solver, _io) in testing_solvers and \
test_solver_cases(_solver, _io).available:
testing_solvers[_solver, _io] = True
def setUpModule():
global testing_solvers
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
for _solver, _io in test_solver_cases():
if (_solver, _io) in testing_solvers and \
test_solver_cases(_solver, _io).available:
testing_solvers[_solver, _io] = True
def test_scenarios(arg=None):
"""
Generate scenarios
"""
for model in sorted(test_models()):
_model = test_models(model)
if not arg is None and not arg(_model):
continue
for solver, io in sorted(test_solver_cases()):
_solver_case = test_solver_cases(solver, io)
_ver = _solver_case.version
# Skip this test case if the solver doesn't support the
# capabilities required by the model
if not _model.capabilities.issubset(_solver_case.capabilities):
continue
# Set status values for expected failures
exclude_suffixes = {}
status = 'ok'
msg = ""
case_skip = SkipTests.get((solver, io, _model.description), None)
case_suffix = MissingSuffixFailures.get(
(solver, io, _model.description), None)
case_fail = ExpectedFailures.get((solver, io, _model.description),
None)
if not _solver_case.available:
status = 'skip'
msg = ("Skipping test because solver %s (%s) is unavailable" %
(solver, io))
elif (case_skip is not None and _ver is not None
and case_skip[0](_ver)):
status = 'skip'
msg = case_skip[1]
elif (case_fail is not None and _ver is not None
and case_fail[0](_ver)):
status = 'expected failure'
msg = case_fail[1]
elif (case_suffix is not None and _ver is not None
and case_suffix[0](_ver)):
if type(case_suffix[1]) is dict:
exclude_suffixes.update(case_suffix[1])
else:
for x in case_suffix[1]:
exclude_suffixes[x] = (True, {})
msg = case_suffix[2]
# Return scenario dimensions and scenario information
yield (model, solver,
io), Bunch(status=status,
msg=msg,
model=_model,
solver=None,
testcase=_solver_case,
demo_limits=_solver_case.demo_limits,
exclude_suffixes=exclude_suffixes)
def test_scenarios(arg=None):
"""
Generate scenarios
"""
for model in sorted(test_models()):
_model = test_models(model)
if not arg is None and not arg(_model):
continue
for solver, io in sorted(test_solver_cases()):
_solver_case = test_solver_cases(solver, io)
# Skip this test case if the solver doesn't support the
# capabilities required by the model
if not _model.capabilities.issubset(_solver_case.capabilities):
continue
# Set status values for expected failures
exclude_suffixes = {}
status = 'ok'
msg = ""
if not _solver_case.available:
status = 'skip'
msg = "Skipping test because solver %s (%s) is unavailable" % (
solver, io)
if (solver, io, _model.description) in ExpectedFailures:
case = ExpectedFailures[solver, io, _model.description]
if _solver_case.version is not None and\
case[0](_solver_case.version):
status = 'expected failure'
msg = case[1]
if (solver, io, _model.description) in MissingSuffixFailures:
case = MissingSuffixFailures[solver, io, _model.description]
if _solver_case.version is not None and\
case[0](_solver_case.version):
if type(case[1]) is dict:
exclude_suffixes.update(case[1])
else:
for x in case[1]:
exclude_suffixes[x] = (True, {})
msg = case[2]
def test_scenarios(arg=None):
"""
Generate scenarios
"""
for model in sorted(test_models()):
_model = test_models(model)
if not arg is None and not arg(_model):
continue
for solver, io in sorted(test_solver_cases()):
_solver_case = test_solver_cases(solver, io)
# Skip this test case if the solver doesn't support the
# capabilities required by the model
if not _model.capabilities.issubset(_solver_case.capabilities):
continue
# Set status values for expected failures
status = 'ok'
msg = ""
if not _solver_case.available:
status = 'skip'
msg = "Skipping test because solver %s (%s) is unavailable" % (
solver, io)
if (solver, io, _model.description) in ExpectedFailures:
case = ExpectedFailures[solver, io, _model.description]
if _solver_case.version is not None and\
case[0](_solver_case.version):
status = 'expected failure'
msg = case[1]
# Return scenario dimensions and scenario information
yield (model, solver, io), Options(status=status,
msg=msg,
model=_model,
solver=None,
testcase=_solver_case)
import pyutilib.th as unittest
from pyomo.common.log import LoggingIntercept
from pyomo.environ import (
ConcreteModel,
Constraint,
Objective,
Var,
log10,
minimize,
)
from pyomo.opt import SolverFactory, TerminationCondition
# check if BARON is available
from pyomo.solvers.tests.solvers import test_solver_cases
baron_available = test_solver_cases('baron', 'bar').available
@unittest.skipIf(not baron_available, "The 'BARON' solver is not available")
class BaronTest(unittest.TestCase):
"""Test the BARON interface."""
def test_log10(self):
# Tests the special transformation for log10
with SolverFactory("baron") as opt:
m = ConcreteModel()
m.x = Var()
m.c = Constraint(expr=log10(m.x) >= 2)
m.obj = Objective(expr=m.x, sense=minimize)
results = opt.solve(m)
def setUpClass(cls):
global scip_available
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
scip_available = test_solver_cases('scip','nl').available
"""Tests the BARON interface."""
import pyutilib.th as unittest
from pyomo.environ import (ConcreteModel, Constraint, Objective, Var, log10,
minimize)
from pyomo.opt import SolverFactory, TerminationCondition
# check if BARON is available
from pyomo.solvers.tests.solvers import test_solver_cases
baron_available = test_solver_cases('baron', 'bar').available
@unittest.skipIf(not baron_available,
"The 'BARON' solver is not available")
class BaronTest(unittest.TestCase):
"""Test the BARON interface."""
def test_log10(self):
# Tests the special transformation for log10
with SolverFactory("baron") as opt:
m = ConcreteModel()
m.x = Var()
m.c = Constraint(expr=log10(m.x) >= 2)
m.obj = Objective(expr=m.x, sense=minimize)
results = opt.solve(m)
self.assertEqual(results.solver.termination_condition,
TerminationCondition.optimal)
def test_abs(self):
def setUpClass(cls):
global cplexamp_available
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
cplexamp_available = test_solver_cases('cplex', 'nl').available
def setUpClass(cls):
global ipopt_available
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
ipopt_available = test_solver_cases('ipopt','nl').available
import pyomo.kernel as pmo
from pyomo.solvers.tests.solvers import test_solver_cases
problems = ['convex_var',
'concave_var',
'piecewise_var',
'step_var']
testing_solvers = {}
#testing_solvers['cplex','lp'] = False
testing_solvers['cplex','nl'] = False
#testing_solvers['ipopt','nl'] = False
#testing_solvers['cplex','python'] = False
#testing_solvers['_cplex_persistent','python'] = False
for _solver, _io in test_solver_cases():
if (_solver, _io) in testing_solvers and \
test_solver_cases(_solver, _io).available:
testing_solvers[_solver, _io] = True
def createTestMethod(pName,problem,solver,writer,kwds):
def testMethod(obj):
if not testing_solvers[solver, writer]:
obj.skipTest("Solver %s (interface=%s) is not available"
% (solver, writer))
m = pyutilib.misc.import_file(os.path.join(thisDir,
'kernel_problems',
problem),
def setUpClass(cls):
global scip_available
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
scip_available = test_solver_cases('scip', 'nl').available
nightly_problems = ['convex_vararray', 'concave_vararray', \
'concave_var','piecewise_var', 'piecewise_vararray']
expensive_problems = ['piecewise_multi_vararray', \
'convex_multi_vararray1','concave_multi_vararray1', \
'convex_multi_vararray2','concave_multi_vararray2']
testing_solvers = {}
#testing_solvers['cplex','lp'] = False
testing_solvers['cplex','nl'] = False
#testing_solvers['ipopt','nl'] = False
#testing_solvers['cplex','python'] = False
#testing_solvers['_cplex_persistent','python'] = False
for _solver, _io in test_solver_cases():
if (_solver, _io) in testing_solvers and \
test_solver_cases(_solver, _io).available:
testing_solvers[_solver, _io] = True
def createTestMethod(pName,problem,solver,writer,kwds):
def testMethod(obj):
if not testing_solvers[solver, writer]:
obj.skipTest("Solver %s (interface=%s) is not available"
% (solver, writer))
m = import_file(os.path.join(thisDir, 'problems', problem + '.py'),
def setUpClass(cls):
global ipopt_available
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
ipopt_available = test_solver_cases('ipopt', 'nl').available
def setUpClass(cls):
global cplexamp_available
import pyomo.environ
from pyomo.solvers.tests.solvers import test_solver_cases
cplexamp_available = test_solver_cases('cplex', 'nl').available
