def setUp(self):
self.model = Model()
x = Variable('x', lb=0, ub=10)
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
obj = Objective(2 * x + y)
self.model.add(x)
self.model.add(y)
self.model.add(constr)
self.model.objective = obj
def test_variable_independence(self):
model = Model()
x = Variable('x', lb=0, ub=20)
self.assertNotEqual(id(x), id(self.model.variables['x']))
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
model.add(constr)
self.assertNotEqual(id(self.model.variables['x']), id(model.variables['x']))
self.assertNotEqual(id(self.model.variables['y']), id(model.variables['y']))
self.assertNotEqual(self.model.variables['y'].problem, model)
self.assertNotEqual(self.model.variables['x'].problem, model)
x.lb = -10
self.assertNotEqual(self.model.variables['x'].lb, model.variables['x'].lb)
def test_variable_independence(self):
model = Model()
x = Variable('x', lb=0, ub=20)
self.assertNotEqual(id(x), id(self.model.variables['x']))
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
model.add(constr)
self.assertNotEqual(id(self.model.variables['x']),
id(model.variables['x']))
self.assertNotEqual(id(self.model.variables['y']),
id(model.variables['y']))
self.assertNotEqual(self.model.variables['y'].problem, model)
self.assertNotEqual(self.model.variables['x'].problem, model)
x.lb = -10
self.assertNotEqual(self.model.variables['x'].lb,
model.variables['x'].lb)
def setUp(self):
self.model = Model()
x = Variable('x', lb=0, ub=10)
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
obj = Objective(2 * x + y)
self.model.add(x)
self.model.add(y)
self.model.add(constr)
self.model.objective = obj
def test_create_empty_model(self):
model = Model()
self.assertEqual(len(model.constraints), 0)
self.assertEqual(len(model.variables), 0)
self.assertEqual(model.objective.expression, 0)
class TestModel(TestCase):
def setUp(self):
self.model = Model()
x = Variable('x', lb=0, ub=10)
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
obj = Objective(2 * x + y)
self.model.add(x)
self.model.add(y)
self.model.add(constr)
self.model.objective = obj
def test_read_only_attributes(self):
self.assertRaises(AttributeError, setattr, self.model, 'variables',
'Foo')
self.assertRaises(AttributeError, setattr, self.model, 'constraints',
'Foo')
self.assertRaises(AttributeError, setattr, self.model, 'status', 'Foo')
def test_create_empty_model(self):
model = Model()
self.assertEqual(len(model.constraints), 0)
self.assertEqual(len(model.variables), 0)
self.assertEqual(model.objective.expression, 0)
def test_add_variable(self):
var = Variable('z')
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(self.model.variables.values().count(var), 1)
self.assertEqual(self.model.variables['z'].problem, var.problem)
var = Variable(
'asdfasdflkjasdflkjasdlkjsadflkjasdflkjasdlfkjasdlfkjasdlkfjasdf',
lb=-13)
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(self.model.variables['z'].lb, None)
self.assertEqual(self.model.variables['z'].ub, None)
self.assertEqual(
self.model.variables[
'asdfasdflkjasdflkjasdlkjsadflkjasdflkjasdlfkjasdlfkjasdlkfjasdf']
.lb, -13)
self.assertEqual(
self.model.variables[
'asdfasdflkjasdflkjasdlkjsadflkjasdflkjasdlfkjasdlfkjasdlkfjasdf']
.ub, None)
def test_add_variable_twice_raises(self):
var = Variable('x')
self.model.add(var)
self.assertRaises(ContainerAlreadyContains, self.model.update)
def test_remove_add_variable(self):
var = self.model.variables[0]
self.model.remove(var)
self.model.add(var)
self.model.update()
def test_remove_add_remove_variable(self):
var = self.model.variables[0]
self.model.remove(var)
self.model.add(var)
# self.assertRaises(ContainerAlreadyContains, self.model.remove, var)
def test_add_existing_variable(self):
var = self.model.variables[0]
self.model.add(var)
self.assertRaises(Exception, self.model.update)
def test_remove_constraint(self):
self.model.remove('constr1')
self.assertEqual(list(self.model.constraints), [])
def test_add_remove_constraint(self):
c = Constraint(self.model.variables.x + self.model.variables.y, lb=10)
self.model.add(c)
self.assertEqual(list(self.model.constraints),
[self.model.constraints['constr1'], c])
self.model.remove(c)
self.model.update()
self.assertEqual(list(self.model.constraints),
[self.model.constraints['constr1']])
def test_add_remove_collection(self):
c = Constraint(self.model.variables.x + self.model.variables.y, lb=10)
c2 = Constraint(3. * self.model.variables.x + self.model.variables.y,
lb=10)
self.model.add([c, c2])
self.assertEqual(list(self.model.constraints),
[self.model.constraints['constr1'], c, c2])
self.model.remove([c, 'constr1', c2])
self.assertEqual(list(self.model.constraints), [])
def test_removing_objective_raises(self):
self.assertRaises(TypeError, self.model.remove, self.model.objective)
def test_removing_crap_raises(self):
self.assertRaises(TypeError, self.model.remove, dict)
def test_remove_variable_str(self):
var = self.model.variables['y']
self.model.remove(var.name)
self.assertNotIn(var, self.model.variables.values())
self.assertEqual(var.problem, None)
self.assertEqual(
self.model.__str__(),
'Maximize\n2.0*x\nsubject to\nconstr1: 3 <= 1.0*x\nBounds\n0 <= x <= 10'
)
def test_number_objective(self):
self.model.objective = Objective(0.)
self.assertEqual(self.model.objective.__str__(), 'Maximize\n0')
def test_add_differing_interface_type_raises(self):
from optlang import glpk_interface as glpk
x, y = glpk.Variable('x'), glpk.Variable('y')
constraint = glpk.Constraint(x + y)
objective = glpk.Objective(1. * x)
self.assertRaises(TypeError, self.model.add, x)
self.assertRaises(TypeError, self.model.add, constraint)
self.assertRaises(TypeError, self.model.add, objective)
def test_setting_binary_bounds(self):
self.model.variables['x'].type = 'binary'
self.assertEqual(self.model.variables['x'].lb, 0)
self.assertEqual(self.model.variables['x'].ub, 1)
def test_non_integer_bound_on_integer_variable_raises(self):
self.model.variables['x'].type = 'integer'
self.assertRaises(ValueError, setattr, self.model.variables['x'], 'lb',
3.3)
def test_non_0_or_1_bound_on_binary_variable_raises(self):
self.model.variables['x'].type = 'integer'
self.assertRaises(ValueError, setattr, self.model.variables['x'], 'lb',
3.3)
def test_false_objective_direction_raises(self):
self.assertRaises(ValueError, setattr, self.model.objective,
'direction', 'neither_min_nor_max')
def test_all_entities_point_to_correct_model(self):
for variable in self.model.variables.values():
self.assertEqual(variable.problem, self.model)
for constraint in self.model.constraints:
self.assertEqual(constraint.problem, self.model)
self.assertEqual(self.model.objective.problem, self.model)
def test_variable_independence(self):
model = Model()
x = Variable('x', lb=0, ub=20)
self.assertNotEqual(id(x), id(self.model.variables['x']))
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
model.add(constr)
self.assertNotEqual(id(self.model.variables['x']),
id(model.variables['x']))
self.assertNotEqual(id(self.model.variables['y']),
id(model.variables['y']))
self.assertNotEqual(self.model.variables['y'].problem, model)
self.assertNotEqual(self.model.variables['x'].problem, model)
x.lb = -10
self.assertNotEqual(self.model.variables['x'].lb,
model.variables['x'].lb)
def test_primal_and_dual_values(self):
model = self.model
self.assertTrue(
all([primal is None for primal in model.primal_values.values()]))
self.assertTrue(
all([
constraint_primal is None
for constraint_primal in model.constraint_values.values()
]))
self.assertTrue(
all([sp is None for sp in model.shadow_prices.values()]))
self.assertTrue(
all([rc is None for rc in model.reduced_costs.values()]))
def test_interface(self):
self.assertEqual(self.model.interface,
sys.modules["optlang.interface"])
class TestModel(TestCase):
def setUp(self):
self.model = Model()
x = Variable('x', lb=0, ub=10)
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
obj = Objective(2 * x + y)
self.model.add(x)
self.model.add(y)
self.model.add(constr)
self.model.objective = obj
def test_read_only_attributes(self):
self.assertRaises(AttributeError, setattr, self.model, 'variables', 'Foo')
self.assertRaises(AttributeError, setattr, self.model, 'constraints', 'Foo')
self.assertRaises(AttributeError, setattr, self.model, 'status', 'Foo')
def test_create_empty_model(self):
model = Model()
self.assertEqual(len(model.constraints), 0)
self.assertEqual(len(model.variables), 0)
self.assertEqual(model.objective.expression - 0, 0)
def test_add_variable(self):
var = Variable('z')
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(self.model.variables.values().count(var), 1)
self.assertEqual(self.model.variables['z'].problem, var.problem)
var = Variable('asdfasdflkjasdflkjasdlkjsadflkjasdflkjasdlfkjasdlfkjasdlkfjasdf', lb=-13)
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(self.model.variables['z'].lb, None)
self.assertEqual(self.model.variables['z'].ub, None)
self.assertEqual(self.model.variables['asdfasdflkjasdflkjasdlkjsadflkjasdflkjasdlfkjasdlfkjasdlkfjasdf'].lb,
-13)
self.assertEqual(self.model.variables['asdfasdflkjasdflkjasdlkjsadflkjasdflkjasdlfkjasdlfkjasdlkfjasdf'].ub,
None)
def test_add_variable_twice_raises(self):
var = Variable('x')
self.model.add(var)
self.assertRaises(ContainerAlreadyContains, self.model.update)
def test_remove_add_variable(self):
var = self.model.variables[0]
self.model.remove(var)
self.model.add(var)
self.model.update()
def test_remove_add_remove_variable(self):
var = self.model.variables[0]
self.model.remove(var)
self.model.add(var)
# self.assertRaises(ContainerAlreadyContains, self.model.remove, var)
def test_add_existing_variable(self):
var = self.model.variables[0]
self.model.add(var)
self.assertRaises(Exception, self.model.update)
def test_remove_constraint(self):
self.model.remove('constr1')
self.assertEqual(list(self.model.constraints), [])
def test_add_remove_constraint(self):
c = Constraint(self.model.variables.x + self.model.variables.y, lb=10)
self.model.add(c)
self.assertEqual(list(self.model.constraints), [self.model.constraints['constr1'], c])
self.model.remove(c)
self.model.update()
self.assertEqual(list(self.model.constraints), [self.model.constraints['constr1']])
def test_add_remove_collection(self):
c = Constraint(self.model.variables.x + self.model.variables.y, lb=10)
c2 = Constraint(3. * self.model.variables.x + self.model.variables.y, lb=10)
self.model.add([c, c2])
self.assertEqual(list(self.model.constraints), [self.model.constraints['constr1'], c, c2])
self.model.remove([c, 'constr1', c2])
self.assertEqual(list(self.model.constraints), [])
def test_removing_objective_raises(self):
self.assertRaises(TypeError, self.model.remove, self.model.objective)
def test_removing_crap_raises(self):
self.assertRaises(TypeError, self.model.remove, dict)
def test_remove_variable_str(self):
var = self.model.variables['y']
self.model.remove(var.name)
self.assertNotIn(var, self.model.variables.values())
self.assertEqual(var.problem, None)
self.assertEqual(self.model.objective.direction, "max")
self.assertEqual(
(self.model.objective.expression - (2.0 * self.model.variables.x)).expand() - 0, 0
)
self.assertEqual(len(self.model.variables), 1)
self.assertEqual(len(self.model.constraints), 1)
self.assertEqual((self.model.variables[0].lb, self.model.variables[0].ub), (0, 10))
self.assertEqual(self.model.constraints[0].lb, 3)
self.assertEqual(
(self.model.constraints[0].expression - (1.0 * self.model.variables.x)).expand() - 0, 0
)
# self.assertEqual(self.model.__str__(), 'Maximize\n2.0*x\nsubject to\nconstr1: 3 <= 1.0*x\nBounds\n0 <= x <= 10')
def test_number_objective(self):
self.model.objective = Objective(0.)
self.assertIn('Maximize\n0', self.model.objective.__str__())
def test_add_differing_interface_type_raises(self):
from optlang import glpk_interface as glpk
x, y = glpk.Variable('x'), glpk.Variable('y')
constraint = glpk.Constraint(x + y)
objective = glpk.Objective(1. * x)
self.assertRaises(TypeError, self.model.add, x)
self.assertRaises(TypeError, self.model.add, constraint)
self.assertRaises(TypeError, self.model.add, objective)
def test_setting_binary_bounds(self):
self.model.variables['x'].type = 'binary'
self.assertEqual(self.model.variables['x'].lb, 0)
self.assertEqual(self.model.variables['x'].ub, 1)
def test_non_integer_bound_on_integer_variable_raises(self):
self.model.variables['x'].type = 'integer'
self.assertRaises(ValueError, setattr, self.model.variables['x'], 'lb', 3.3)
def test_non_0_or_1_bound_on_binary_variable_raises(self):
self.model.variables['x'].type = 'integer'
self.assertRaises(ValueError, setattr, self.model.variables['x'], 'lb', 3.3)
def test_false_objective_direction_raises(self):
self.assertRaises(ValueError, setattr, self.model.objective, 'direction', 'neither_min_nor_max')
def test_all_entities_point_to_correct_model(self):
for variable in self.model.variables.values():
self.assertEqual(variable.problem, self.model)
for constraint in self.model.constraints:
self.assertEqual(constraint.problem, self.model)
self.assertEqual(self.model.objective.problem, self.model)
def test_variable_independence(self):
model = Model()
x = Variable('x', lb=0, ub=20)
self.assertNotEqual(id(x), id(self.model.variables['x']))
y = Variable('y', lb=0, ub=10)
constr = Constraint(1. * x + y, lb=3, name="constr1")
model.add(constr)
self.assertNotEqual(id(self.model.variables['x']), id(model.variables['x']))
self.assertNotEqual(id(self.model.variables['y']), id(model.variables['y']))
self.assertNotEqual(self.model.variables['y'].problem, model)
self.assertNotEqual(self.model.variables['x'].problem, model)
x.lb = -10
self.assertNotEqual(self.model.variables['x'].lb, model.variables['x'].lb)
def test_primal_and_dual_values(self):
model = self.model
self.assertTrue(all([primal is None for primal in model.primal_values.values()]))
self.assertTrue(all([constraint_primal is None for constraint_primal in model.constraint_values.values()]))
self.assertTrue(all([sp is None for sp in model.shadow_prices.values()]))
self.assertTrue(all([rc is None for rc in model.reduced_costs.values()]))
def test_interface(self):
self.assertEqual(self.model.interface, sys.modules["optlang.interface"])
def setUp(self):
self.model = Model()
self.container = self.model.variables
class ContainerTestCase(unittest.TestCase):
def setUp(self):
self.model = Model()
self.container = self.model.variables
def test_container_from_iterable(self):
variables_iterable = [Variable("v" + str(i), lb=10, ub=100) for i in range(10000)]
container = Container(variables_iterable)
self.assertEqual(len(container), 10000)
for index, variable in enumerate(variables_iterable):
self.assertEqual(container[index], variable)
self.assertEqual(container[variable.name], variable)
def test_container_from_iterable_with_items_without_name_attribute_raise(self):
variables_iterable = ['v' + str(i) for i in range(10000)]
self.assertRaises(AttributeError, Container, variables_iterable)
def test_container_append(self):
var = Variable('blub')
self.container.append(var)
self.assertEqual(len(self.container), 1)
self.assertEqual(self.container['blub'], var)
self.assertEqual(self.container[0], var)
def test_dir(self):
var = Variable('blub')
self.container.append(var)
print(dir(self.container))
self.assertEqual(dir(self.container),
['__contains__', '__delitem__', '__dict__', '__dir__', '__doc__', '__getattr__', '__getitem__',
'__getstate__', '__init__', '__iter__', '__len__', '__module__', '__setitem__',
'__setstate__', '__weakref__', '_check_for_name_attribute', '_reindex', 'append', 'blub',
'clear', 'extend', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys',
'itervalues', 'keys', 'update_key', 'values'])
def test_del_by_index(self):
variables_iterable = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
container = Container(variables_iterable)
del container[10]
for i, variable in enumerate(container):
if i < 10:
self.assertEqual(int(variable.name.replace('v', '')), i)
else:
self.assertEqual(int(variable.name.replace('v', '')) - 1, i)
def test_del_by_key(self):
variables_iterable = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
container = Container(variables_iterable)
del container["v333"]
for i, variable in enumerate(container):
if i < 333:
self.assertEqual(int(variable.name.replace('v', '')), i)
else:
self.assertEqual(int(variable.name.replace('v', '')) - 1, i)
def test_non_name_item_raises(self):
self.assertRaises(AttributeError, self.container.append, 3)
def test_add_already_existing_item_raises(self):
var = Variable('blub')
self.container.append(var)
self.assertRaises(Exception, self.container.append, var)
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(100)]
self.container.extend(variables)
self.assertRaises(Exception, self.container.extend, variables)
def test_clear(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
self.container.clear()
self.assertEqual(len(self.container), 0)
self.assertEqual(self.container._object_list, [])
self.assertEqual(self.container._indices, {})
self.assertEqual(self.container._dict, {})
def test_extend(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
def test_iterkeys(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
generator = self.container.iterkeys()
self.assertEqual(list(generator), [item.name for item in self.container])
def test_keys(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
keys = self.container.keys()
self.assertEqual(keys, [item.name for item in self.container])
def test_itervalues(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
generator = self.container.itervalues()
self.assertEqual(list(generator), variables)
def test_values(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
values = self.container.values()
self.assertEqual(values, variables)
def test_iteritems(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
generator = self.container.iteritems()
self.assertEqual(list(generator), [(variable.name, variable) for variable in variables])
def test_fromkeys(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(1000)]
self.container.extend(variables)
sub_container = self.container.fromkeys(('v1', 'v66', 'v999'))
print(sub_container._object_list)
lookalike = Container([variables[i] for i in (1, 66, 999)])
print(lookalike._object_list)
self.assertEqual(sub_container._object_list, lookalike._object_list)
# self.assertEqual(sub_container._name_list, lookalike._name_list)
self.assertEqual(sub_container._dict, lookalike._dict)
def test_get(self):
var = Variable('blub')
self.container.append(var)
self.assertEqual(self.container.get('blub'), var)
self.assertEqual(self.container.get('blurb', None), None)
def test_has_key(self):
self.assertFalse('blurb' in self.container)
self.assertFalse(self.container.has_key('blurb')) # noqa: W601
var = Variable('blurb')
self.container.append(var)
self.assertTrue('blurb' in self.container)
self.assertTrue(self.container.has_key('blurb')) # noqa: W601
def test_getattr(self):
var = Variable('variable1')
self.container.append(var)
self.assertEqual(self.container.variable1, var)
self.assertRaises(AttributeError, getattr, self.container, 'not_existing_variable')
def test_setitem(self):
var = Variable('blub')
self.assertRaises(IndexError, self.container.__setitem__, 0, var)
self.container.append(var)
self.assertEqual(self.container[0], var)
var2 = Variable('blib')
self.container[0] = var2
self.assertEqual(self.container[0], var2)
var3 = Variable("blab")
self.assertRaises(ValueError, self.container.__setitem__, "blub", var3)
self.container["blab"] = var3
self.assertIs(self.container["blab"], var3)
self.assertIs(self.container[1], var3)
var4 = Variable("blab")
self.container["blab"] = var4
self.assertFalse(var3 in self.container)
self.assertIs(self.container["blab"], var4)
self.assertIs(self.container[1], var4)
self.assertRaises(ValueError, self.container.__setitem__, 1, var2)
self.container[1] = var3
self.assertIs(self.container["blab"], var3)
self.assertIs(self.container[1], var3)
self.container.update_key("blab")
def test_change_object_name(self):
var = Variable('blub')
self.model.add(var)
self.model.update()
var.name = 'blurg'
self.assertEqual(self.container.keys(), ['blurg'])
self.assertEqual(self.container['blurg'], var)
def test_iter_container_len_change_raises(self):
def _(container):
for item in container:
del container[item.name]
variables_iterable = [Variable("v" + str(i), lb=10, ub=100) for i in range(10)]
container = Container(variables_iterable)
self.assertRaises(RuntimeError, _, container)
def test_pickle(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(100)]
self.container.extend(variables)
unpickled = pickle.loads(pickle.dumps(self.container))
self.assertEquals(unpickled[0].name, variables[0].name)
def setUp(self):
self.model = Model()
self.container = self.model.variables
class ContainerTestCase(unittest.TestCase):
def setUp(self):
self.model = Model()
self.container = self.model.variables
def test_container_from_iterable(self):
variables_iterable = [
Variable("v" + str(i), lb=10, ub=100) for i in range(10000)
]
container = Container(variables_iterable)
self.assertEqual(len(container), 10000)
for index, variable in enumerate(variables_iterable):
self.assertEqual(container[index], variable)
self.assertEqual(container[variable.name], variable)
def test_container_from_iterable_with_items_without_name_attribute_raise(
self):
variables_iterable = ['v' + str(i) for i in range(10000)]
self.assertRaises(AttributeError, Container, variables_iterable)
def test_container_append(self):
var = Variable('blub')
self.container.append(var)
self.assertEqual(len(self.container), 1)
self.assertEqual(self.container['blub'], var)
self.assertEqual(self.container[0], var)
def test_dir(self):
var = Variable('blub')
self.container.append(var)
print(dir(self.container))
self.assertEqual(dir(self.container), [
'__contains__', '__delitem__', '__dict__', '__dir__', '__doc__',
'__getattr__', '__getitem__', '__getstate__', '__init__',
'__iter__', '__len__', '__module__', '__setitem__', '__setstate__',
'__weakref__', '_check_for_name_attribute', '_reindex', 'append',
'blub', 'clear', 'extend', 'fromkeys', 'get', 'has_key', 'items',
'iteritems', 'iterkeys', 'itervalues', 'keys', 'update_key',
'values'
])
def test_del_by_index(self):
variables_iterable = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
container = Container(variables_iterable)
del container[10]
for i, variable in enumerate(container):
if i < 10:
self.assertEqual(int(variable.name.replace('v', '')), i)
else:
self.assertEqual(int(variable.name.replace('v', '')) - 1, i)
def test_del_by_key(self):
variables_iterable = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
container = Container(variables_iterable)
del container["v333"]
for i, variable in enumerate(container):
if i < 333:
self.assertEqual(int(variable.name.replace('v', '')), i)
else:
self.assertEqual(int(variable.name.replace('v', '')) - 1, i)
def test_non_name_item_raises(self):
self.assertRaises(AttributeError, self.container.append, 3)
def test_add_already_existing_item_raises(self):
var = Variable('blub')
self.container.append(var)
self.assertRaises(Exception, self.container.append, var)
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(100)]
self.container.extend(variables)
self.assertRaises(Exception, self.container.extend, variables)
def test_clear(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
self.container.clear()
self.assertEqual(len(self.container), 0)
self.assertEqual(self.container._object_list, [])
self.assertEqual(self.container._indices, {})
self.assertEqual(self.container._dict, {})
def test_extend(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
def test_iterkeys(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
generator = self.container.iterkeys()
self.assertEqual(list(generator),
[item.name for item in self.container])
def test_keys(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
keys = self.container.keys()
self.assertEqual(keys, [item.name for item in self.container])
def test_itervalues(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
generator = self.container.itervalues()
self.assertEqual(list(generator), variables)
def test_values(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
values = self.container.values()
self.assertEqual(values, variables)
def test_iteritems(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
generator = self.container.iteritems()
self.assertEqual(list(generator),
[(variable.name, variable) for variable in variables])
def test_fromkeys(self):
variables = [
Variable("v" + str(i), lb=10, ub=100) for i in range(1000)
]
self.container.extend(variables)
sub_container = self.container.fromkeys(('v1', 'v66', 'v999'))
print(sub_container._object_list)
lookalike = Container([variables[i] for i in (1, 66, 999)])
print(lookalike._object_list)
self.assertEqual(sub_container._object_list, lookalike._object_list)
# self.assertEqual(sub_container._name_list, lookalike._name_list)
self.assertEqual(sub_container._dict, lookalike._dict)
def test_get(self):
var = Variable('blub')
self.container.append(var)
self.assertEqual(self.container.get('blub'), var)
self.assertEqual(self.container.get('blurb', None), None)
def test_has_key(self):
self.assertFalse('blurb' in self.container)
self.assertFalse(self.container.has_key('blurb')) # noqa: W601
var = Variable('blurb')
self.container.append(var)
self.assertTrue('blurb' in self.container)
self.assertTrue(self.container.has_key('blurb')) # noqa: W601
def test_getattr(self):
var = Variable('variable1')
self.container.append(var)
self.assertEqual(self.container.variable1, var)
self.assertRaises(AttributeError, getattr, self.container,
'not_existing_variable')
def test_setitem(self):
var = Variable('blub')
self.assertRaises(IndexError, self.container.__setitem__, 0, var)
self.container.append(var)
self.assertEqual(self.container[0], var)
var2 = Variable('blib')
self.container[0] = var2
self.assertEqual(self.container[0], var2)
var3 = Variable("blab")
self.assertRaises(ValueError, self.container.__setitem__, "blub", var3)
self.container["blab"] = var3
self.assertIs(self.container["blab"], var3)
self.assertIs(self.container[1], var3)
var4 = Variable("blab")
self.container["blab"] = var4
self.assertFalse(var3 in self.container)
self.assertIs(self.container["blab"], var4)
self.assertIs(self.container[1], var4)
self.assertRaises(ValueError, self.container.__setitem__, 1, var2)
self.container[1] = var3
self.assertIs(self.container["blab"], var3)
self.assertIs(self.container[1], var3)
self.container.update_key("blab")
def test_change_object_name(self):
var = Variable('blub')
self.model.add(var)
self.model.update()
var.name = 'blurg'
self.assertEqual(self.container.keys(), ['blurg'])
self.assertEqual(self.container['blurg'], var)
def test_iter_container_len_change_raises(self):
def _(container):
for item in container:
del container[item.name]
variables_iterable = [
Variable("v" + str(i), lb=10, ub=100) for i in range(10)
]
container = Container(variables_iterable)
self.assertRaises(RuntimeError, _, container)
def test_pickle(self):
variables = [Variable("v" + str(i), lb=10, ub=100) for i in range(100)]
self.container.extend(variables)
unpickled = pickle.loads(pickle.dumps(self.container))
self.assertEquals(unpickled[0].name, variables[0].name)
def test_change_problem(self):
model = Model()
self.var.problem = model
self.assertEqual(self.var.problem, model)
