def test_name(self):
s = suffix()
self.assertTrue(s.parent is None)
self.assertEqual(s.local_name, None)
self.assertEqual(s.name, None)
model = block()
model.s = s
self.assertTrue(model.parent is None)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "s")
b = block()
b.model = model
self.assertTrue(b.parent is None)
self.assertTrue(model.parent is b)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "model.s")
bdict = block_dict()
bdict[0] = b
self.assertTrue(bdict.parent is None)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "[0].model.s")
m = block()
m.bdict = bdict
self.assertTrue(m.parent is None)
self.assertTrue(bdict.parent is m)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "bdict[0].model.s")
def test_name(self):
s = suffix()
self.assertTrue(s.parent is None)
self.assertEqual(s.local_name, None)
self.assertEqual(s.name, None)
model = block()
model.s = s
self.assertTrue(model.parent is None)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "s")
b = block()
b.model = model
self.assertTrue(b.parent is None)
self.assertTrue(model.parent is b)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "model.s")
bdict = block_dict()
bdict[0] = b
self.assertTrue(bdict.parent is None)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "[0].model.s")
m = block()
m.bdict = bdict
self.assertTrue(m.parent is None)
self.assertTrue(bdict.parent is m)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(s.parent is model)
self.assertEqual(s.local_name, "s")
self.assertEqual(s.name, "bdict[0].model.s")
def test_active(self):
s = suffix()
with self.assertRaises(AttributeError):
s.active = False
model = block()
model.s = s
b = block()
b.model = model
bdict = block_dict()
bdict[0] = b
bdict[None] = block()
m = block()
m.bdict = bdict
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
m.deactivate(shallow=False)
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(s.active, False)
m.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
m.deactivate()
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
m.deactivate(shallow=False)
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(s.active, False)
m.activate()
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(s.active, False)
m.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
def test_active(self):
children = {}
children['a'] = self._ctype_factory()
children[1] = self._ctype_factory()
children[None] = self._ctype_factory()
children[(1, )] = self._ctype_factory()
children[(1, 2)] = self._ctype_factory()
children['(1,2)'] = self._ctype_factory()
cdict = self._container_type()
cdict.update(children)
with self.assertRaises(AttributeError):
cdict.active = False
for c in cdict.values():
with self.assertRaises(AttributeError):
c.active = False
model = block()
model.cdict = cdict
b = block()
b.model = model
bdict = block_dict()
bdict[0] = b
bdict[None] = block()
m = block()
m.bdict = bdict
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for c in cdict.values():
self.assertEqual(c.active, True)
for c in cdict.components():
self.assertEqual(c.active, True)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertEqual(len(list(cdict.components())), len(cdict))
self.assertEqual(len(list(cdict.components())),
len(list(cdict.components(active=True))))
m.deactivate(shallow=False)
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, False)
for c in cdict.values():
self.assertEqual(c.active, False)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 0)
test_key = list(children.keys())[0]
del cdict[test_key]
cdict[test_key] = children[test_key]
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, False)
for c in cdict.values():
self.assertEqual(c.active, False)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 0)
del cdict[test_key]
children[test_key].activate()
self.assertEqual(children[test_key].active, True)
cdict[test_key] = children[test_key]
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, False)
cdict.activate()
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, True)
for key, c in cdict.items():
if key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components():
if c.storage_key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 1)
cdict.deactivate()
m.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for c in cdict.values():
self.assertEqual(c.active, True)
for c in cdict.components():
self.assertEqual(c.active, True)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertEqual(len(list(cdict.components())), len(cdict))
self.assertEqual(len(list(cdict.components())),
len(list(cdict.components(active=True))))
cdict.deactivate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, False)
for c in cdict.values():
self.assertEqual(c.active, False)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 0)
cdict.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for c in cdict.values():
self.assertEqual(c.active, True)
for c in cdict.components():
self.assertEqual(c.active, True)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertEqual(len(list(cdict.components())), len(cdict))
self.assertEqual(len(list(cdict.components())),
len(list(cdict.components(active=True))))
cdict.deactivate(shallow=False)
cdict[test_key].activate()
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, False)
cdict.activate()
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for key, c in cdict.items():
if key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components():
if c.storage_key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 1)
def test_name(self):
children = {}
children['a'] = self._ctype_factory()
children[1] = self._ctype_factory()
children[None] = self._ctype_factory()
children[(1, )] = self._ctype_factory()
children[(1, 2)] = self._ctype_factory()
children['(1,2)'] = self._ctype_factory()
children['x'] = self._container_type()
children['x']['y'] = self._ctype_factory()
for key, c in children.items():
self.assertTrue(c.parent is None)
self.assertEqual(c.local_name, None)
self.assertEqual(c.name, None)
cdict = self._container_type()
self.assertTrue(cdict.parent is None)
self.assertEqual(cdict.local_name, None)
self.assertEqual(cdict.name, None)
cdict.update(children)
names = pmo.generate_names(cdict)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
model = block()
model.cdict = cdict
self.assertTrue(model.parent is None)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "cdict")
names = pmo.generate_names(model)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"cdict[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
b = block()
b.model = model
self.assertTrue(b.parent is None)
self.assertTrue(model.parent is b)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "model.cdict")
names = pmo.generate_names(b)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"model.cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"model.cdict[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
bdict = block_dict()
bdict[0] = b
self.assertTrue(bdict.parent is None)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "[0].model.cdict")
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"[0].model.cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"[0].model.cdict[%s]" % (repr(key)))
m = block()
m.bdict = bdict
self.assertTrue(m.parent is None)
self.assertTrue(bdict.parent is m)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "bdict[0].model.cdict")
names = pmo.generate_names(m)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"bdict[0].model.cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"bdict[0].model.cdict[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
names = pmo.generate_names(m)
for c in m.children():
self.assertEqual(c.name, names[c])
class TestComponentSet(unittest.TestCase):
_components = [
variable(),
variable_dict(),
variable_list(),
constraint(),
constraint_dict(),
constraint_list(),
objective(),
objective_dict(),
objective_list(),
expression(),
expression_dict(),
expression_list(),
block(),
block_dict(),
block_list(),
suffix()
]
def test_pickle(self):
c = ComponentSet()
self.assertEqual(len(c), 0)
cup = pickle.loads(pickle.dumps(c))
self.assertIsNot(cup, c)
self.assertEqual(len(cup), 0)
v = variable()
c.add(v)
self.assertEqual(len(c), 1)
self.assertTrue(v in c)
cup = pickle.loads(pickle.dumps(c))
vup = cup.pop()
cup.add(vup)
self.assertIsNot(cup, c)
self.assertIsNot(vup, v)
self.assertEqual(len(cup), 1)
self.assertTrue(vup in cup)
self.assertEqual(vup.parent, None)
b = block()
V = b.V = variable_list()
b.V.append(v)
b.c = c
self.assertEqual(len(c), 1)
self.assertTrue(v in c)
self.assertIs(v.parent, b.V)
self.assertIs(V.parent, b)
self.assertIs(b.parent, None)
bup = pickle.loads(pickle.dumps(b))
Vup = bup.V
vup = Vup[0]
cup = bup.c
self.assertIsNot(cup, c)
self.assertIsNot(vup, v)
self.assertIsNot(Vup, V)
self.assertIsNot(bup, b)
self.assertEqual(len(cup), 1)
self.assertTrue(vup in cup)
self.assertIs(vup.parent, Vup)
self.assertIs(Vup.parent, bup)
self.assertIs(bup.parent, None)
self.assertEqual(len(c), 1)
self.assertTrue(v in c)
def test_init(self):
cset = ComponentSet()
cset = ComponentSet(self._components)
with self.assertRaises(TypeError):
cset = ComponentSet(*self._components)
def test_type(self):
cset = ComponentSet()
self.assertTrue(isinstance(cset, collections.abc.Set))
self.assertTrue(isinstance(cset, collections.abc.MutableSet))
self.assertTrue(issubclass(type(cset), collections.abc.Set))
self.assertTrue(issubclass(type(cset), collections.abc.MutableSet))
def test_str(self):
cset = ComponentSet()
self.assertEqual(str(cset), "ComponentSet([])")
cset.update(self._components)
str(cset)
def test_len(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
cset.update(self._components)
self.assertEqual(len(cset), len(self._components))
cset = ComponentSet(self._components)
self.assertEqual(len(cset), len(self._components))
self.assertTrue(len(self._components) > 0)
def test_iter(self):
cset = ComponentSet()
self.assertEqual(list(iter(cset)), [])
cset.update(self._components)
ids_seen = set()
for c in cset:
ids_seen.add(id(c))
self.assertEqual(ids_seen, set(id(c) for c in self._components))
def set_add(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
for i, c in enumerate(self._components):
self.assertTrue(c not in cset)
cset.add(c)
self.assertTrue(c in cset)
self.assertEqual(len(cset), i + 1)
self.assertEqual(len(cset), len(self._components))
for c in self._components:
self.assertTrue(c in cset)
cset.add(c)
self.assertTrue(c in cset)
self.assertEqual(len(cset), len(self._components))
def test_pop(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
with self.assertRaises(KeyError):
cset.pop()
v = variable()
cset.add(v)
self.assertTrue(v in cset)
self.assertEqual(len(cset), 1)
v_ = cset.pop()
self.assertIs(v, v_)
self.assertTrue(v not in cset)
self.assertEqual(len(cset), 0)
def test_update(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
cset.update(self._components)
self.assertEqual(len(cset), len(self._components))
for c in self._components:
self.assertTrue(c in cset)
def test_clear(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
cset.update(self._components)
self.assertEqual(len(cset), len(self._components))
cset.clear()
self.assertEqual(len(cset), 0)
def test_remove(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
cset.update(self._components)
self.assertEqual(len(cset), len(self._components))
for i, c in enumerate(self._components):
cset.remove(c)
self.assertEqual(len(cset), len(self._components) - (i + 1))
for c in self._components:
self.assertTrue(c not in cset)
with self.assertRaises(KeyError):
cset.remove(c)
def test_discard(self):
cset = ComponentSet()
self.assertEqual(len(cset), 0)
cset.update(self._components)
self.assertEqual(len(cset), len(self._components))
for i, c in enumerate(self._components):
cset.discard(c)
self.assertEqual(len(cset), len(self._components) - (i + 1))
for c in self._components:
self.assertTrue(c not in cset)
cset.discard(c)
def test_isdisjoint(self):
cset1 = ComponentSet()
cset2 = ComponentSet()
self.assertTrue(cset1.isdisjoint(cset2))
self.assertTrue(cset2.isdisjoint(cset1))
v = variable()
cset1.add(v)
self.assertTrue(cset1.isdisjoint(cset2))
self.assertTrue(cset2.isdisjoint(cset1))
cset2.add(v)
self.assertFalse(cset1.isdisjoint(cset2))
self.assertFalse(cset2.isdisjoint(cset1))
def test_misc_set_ops(self):
v1 = variable()
cset1 = ComponentSet([v1])
v2 = variable()
cset2 = ComponentSet([v2])
cset3 = ComponentSet([v1, v2])
empty = ComponentSet([])
self.assertEqual(cset1 | cset2, cset3)
self.assertEqual((cset1 | cset2) - cset3, empty)
self.assertEqual(cset1 ^ cset2, cset3)
self.assertEqual(cset1 ^ cset3, cset2)
self.assertEqual(cset2 ^ cset3, cset1)
self.assertEqual(cset1 & cset2, empty)
self.assertEqual(cset1 & cset3, cset1)
self.assertEqual(cset2 & cset3, cset2)
def test_eq(self):
cset1 = ComponentSet()
self.assertEqual(cset1, set())
self.assertTrue(cset1 == set())
self.assertNotEqual(cset1, list())
self.assertFalse(cset1 == list())
self.assertNotEqual(cset1, tuple())
self.assertFalse(cset1 == tuple())
self.assertNotEqual(cset1, dict())
self.assertFalse(cset1 == dict())
cset1.update(self._components)
self.assertNotEqual(cset1, set())
self.assertFalse(cset1 == set())
self.assertNotEqual(cset1, list())
self.assertFalse(cset1 == list())
self.assertNotEqual(cset1, tuple())
self.assertFalse(cset1 == tuple())
self.assertNotEqual(cset1, dict())
self.assertFalse(cset1 == dict())
self.assertTrue(cset1 == cset1)
self.assertEqual(cset1, cset1)
cset2 = ComponentSet(self._components)
self.assertTrue(cset2 == cset1)
self.assertFalse(cset2 != cset1)
self.assertEqual(cset2, cset1)
self.assertTrue(cset1 == cset2)
self.assertFalse(cset1 != cset2)
self.assertEqual(cset1, cset2)
cset2.remove(self._components[0])
self.assertFalse(cset2 == cset1)
self.assertTrue(cset2 != cset1)
self.assertNotEqual(cset2, cset1)
self.assertFalse(cset1 == cset2)
self.assertTrue(cset1 != cset2)
self.assertNotEqual(cset1, cset2)
def test_active(self):
children = {}
children['a'] = self._ctype_factory()
children[1] = self._ctype_factory()
children[None] = self._ctype_factory()
children[(1,)] = self._ctype_factory()
children[(1,2)] = self._ctype_factory()
children['(1,2)'] = self._ctype_factory()
cdict = self._container_type()
cdict.update(children)
with self.assertRaises(AttributeError):
cdict.active = False
for c in cdict.values():
with self.assertRaises(AttributeError):
c.active = False
model = block()
model.cdict = cdict
b = block()
b.model = model
bdict = block_dict()
bdict[0] = b
bdict[None] = block()
m = block()
m.bdict = bdict
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for c in cdict.values():
self.assertEqual(c.active, True)
for c in cdict.components():
self.assertEqual(c.active, True)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertEqual(len(list(cdict.components())), len(cdict))
self.assertEqual(len(list(cdict.components())),
len(list(cdict.components(active=True))))
m.deactivate(shallow=False)
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, False)
for c in cdict.values():
self.assertEqual(c.active, False)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 0)
test_key = list(children.keys())[0]
del cdict[test_key]
cdict[test_key] = children[test_key]
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, False)
for c in cdict.values():
self.assertEqual(c.active, False)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 0)
del cdict[test_key]
children[test_key].activate()
self.assertEqual(children[test_key].active, True)
cdict[test_key] = children[test_key]
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, False)
cdict.activate()
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(cdict.active, True)
for key, c in cdict.items():
if key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components():
if c.storage_key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 1)
cdict.deactivate()
m.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for c in cdict.values():
self.assertEqual(c.active, True)
for c in cdict.components():
self.assertEqual(c.active, True)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertEqual(len(list(cdict.components())), len(cdict))
self.assertEqual(len(list(cdict.components())),
len(list(cdict.components(active=True))))
cdict.deactivate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, False)
for c in cdict.values():
self.assertEqual(c.active, False)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 0)
cdict.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for c in cdict.values():
self.assertEqual(c.active, True)
for c in cdict.components():
self.assertEqual(c.active, True)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertEqual(len(list(cdict.components())), len(cdict))
self.assertEqual(len(list(cdict.components())),
len(list(cdict.components(active=True))))
cdict.deactivate(shallow=False)
cdict[test_key].activate()
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, False)
cdict.activate()
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(cdict.active, True)
for key, c in cdict.items():
if key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components():
if c.storage_key == test_key:
self.assertEqual(c.active, True)
else:
self.assertEqual(c.active, False)
for c in cdict.components(active=True):
self.assertEqual(c.active, True)
self.assertNotEqual(len(list(cdict.components())),
len(list(cdict.components(active=None))))
self.assertEqual(len(list(cdict.components(active=True))), 1)
def test_name(self):
children = {}
children['a'] = self._ctype_factory()
children[1] = self._ctype_factory()
children[None] = self._ctype_factory()
children[(1,)] = self._ctype_factory()
children[(1,2)] = self._ctype_factory()
children['(1,2)'] = self._ctype_factory()
children['x'] = self._container_type()
children['x']['y'] = self._ctype_factory()
for key, c in children.items():
self.assertTrue(c.parent is None)
self.assertEqual(c.local_name, None)
self.assertEqual(c.name, None)
cdict = self._container_type()
self.assertTrue(cdict.parent is None)
self.assertEqual(cdict.local_name, None)
self.assertEqual(cdict.name, None)
cdict.update(children)
names = pmo.generate_names(cdict)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
model = block()
model.cdict = cdict
self.assertTrue(model.parent is None)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "cdict")
names = pmo.generate_names(model)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"cdict[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
b = block()
b.model = model
self.assertTrue(b.parent is None)
self.assertTrue(model.parent is b)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "model.cdict")
names = pmo.generate_names(b)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"model.cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"model.cdict[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
bdict = block_dict()
bdict[0] = b
self.assertTrue(bdict.parent is None)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "[0].model.cdict")
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"[0].model.cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"[0].model.cdict[%s]" % (repr(key)))
m = block()
m.bdict = bdict
self.assertTrue(m.parent is None)
self.assertTrue(bdict.parent is m)
self.assertTrue(b.parent is bdict)
self.assertTrue(model.parent is b)
self.assertTrue(cdict.parent is model)
self.assertEqual(cdict.local_name, "cdict")
self.assertEqual(cdict.name, "bdict[0].model.cdict")
names = pmo.generate_names(m)
for key, c in children.items():
self.assertTrue(c.parent is cdict)
self.assertEqual(c.getname(fully_qualified=False, convert=str),
"[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=False, convert=repr),
"[%s]" % (repr(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=str),
"bdict[0].model.cdict[%s]" % (str(key)))
self.assertEqual(c.getname(fully_qualified=True, convert=repr),
"bdict[0].model.cdict[%s]" % (repr(key)))
self.assertEqual(c.name, names[c])
for c in cdict.components():
self.assertNotEqual(c.name, None)
self.assertEqual(c.name, names[c])
names = pmo.generate_names(m)
for c in m.children():
self.assertEqual(c.name, names[c])
class TestComponentMap(unittest.TestCase):
_components = [(variable(), "v"),
(variable_dict(), "vdict"),
(variable_list(), "vlist"),
(constraint(), "c"),
(constraint_dict(), "cdict"),
(constraint_list(), "clist"),
(objective(), "o"),
(objective_dict(), "odict"),
(objective_list(), "olist"),
(expression(), "e"),
(expression_dict(), "edict"),
(expression_list(), "elist"),
(block(), "b"),
(block_dict(), "bdict"),
(block_list(), "blist"),
(suffix(), "s")]
def test_pickle(self):
c = ComponentMap()
self.assertEqual(len(c), 0)
cup = pickle.loads(
pickle.dumps(c))
self.assertIsNot(cup, c)
self.assertEqual(len(cup), 0)
v = variable()
c[v] = 1.0
self.assertEqual(len(c), 1)
self.assertEqual(c[v], 1.0)
cup = pickle.loads(
pickle.dumps(c))
vup = list(cup.keys())[0]
self.assertIsNot(cup, c)
self.assertIsNot(vup, v)
self.assertEqual(len(cup), 1)
self.assertEqual(cup[vup], 1)
self.assertEqual(vup.parent, None)
b = block()
V = b.V = variable_list()
b.V.append(v)
b.c = c
self.assertEqual(len(c), 1)
self.assertEqual(c[v], 1.0)
self.assertIs(v.parent, b.V)
self.assertIs(V.parent, b)
self.assertIs(b.parent, None)
bup = pickle.loads(
pickle.dumps(b))
Vup = bup.V
vup = Vup[0]
cup = bup.c
self.assertIsNot(cup, c)
self.assertIsNot(vup, v)
self.assertIsNot(Vup, V)
self.assertIsNot(bup, b)
self.assertEqual(len(cup), 1)
self.assertEqual(cup[vup], 1)
self.assertIs(vup.parent, Vup)
self.assertIs(Vup.parent, bup)
self.assertIs(bup.parent, None)
self.assertEqual(len(c), 1)
self.assertEqual(c[v], 1)
def test_init(self):
cmap = ComponentMap()
cmap = ComponentMap(self._components)
with self.assertRaises(TypeError):
cmap = ComponentMap(*self._components)
def test_type(self):
cmap = ComponentMap()
self.assertTrue(isinstance(cmap, collections_Mapping))
self.assertTrue(isinstance(cmap, collections_MutableMapping))
self.assertTrue(issubclass(type(cmap), collections_Mapping))
self.assertTrue(issubclass(type(cmap), collections_MutableMapping))
def test_str(self):
cmap = ComponentMap()
self.assertEqual(str(cmap), "ComponentMap({})")
cmap.update(self._components)
str(cmap)
def test_len(self):
cmap = ComponentMap()
self.assertEqual(len(cmap), 0)
cmap.update(self._components)
self.assertEqual(len(cmap), len(self._components))
cmap = ComponentMap(self._components)
self.assertEqual(len(cmap), len(self._components))
self.assertTrue(len(self._components) > 0)
def test_getsetdelitem(self):
cmap = ComponentMap()
for c, val in self._components:
self.assertTrue(c not in cmap)
for c, val in self._components:
cmap[c] = val
self.assertEqual(cmap[c], val)
self.assertEqual(cmap.get(c), val)
del cmap[c]
with self.assertRaises(KeyError):
cmap[c]
with self.assertRaises(KeyError):
del cmap[c]
self.assertEqual(cmap.get(c), None)
def test_iter(self):
cmap = ComponentMap()
self.assertEqual(list(iter(cmap)), [])
cmap.update(self._components)
ids_seen = set()
for c in cmap:
ids_seen.add(id(c))
self.assertEqual(ids_seen,
set(id(c) for c,val in self._components))
def test_keys(self):
cmap = ComponentMap(self._components)
self.assertEqual(sorted(cmap.keys(), key=id),
sorted(list(c for c,val in self._components),
key=id))
def test_values(self):
cmap = ComponentMap(self._components)
self.assertEqual(sorted(cmap.values()),
sorted(list(val for c,val in self._components)))
def test_items(self):
cmap = ComponentMap(self._components)
for x in cmap.items():
self.assertEqual(type(x), tuple)
self.assertEqual(len(x), 2)
self.assertEqual(sorted(cmap.items(),
key=lambda _x: (id(_x[0]), _x[1])),
sorted(self._components,
key=lambda _x: (id(_x[0]), _x[1])))
def test_update(self):
cmap = ComponentMap()
self.assertEqual(len(cmap), 0)
cmap.update(self._components)
self.assertEqual(len(cmap), len(self._components))
for c, val in self._components:
self.assertEqual(cmap[c], val)
def test_clear(self):
cmap = ComponentMap()
self.assertEqual(len(cmap), 0)
cmap.update(self._components)
self.assertEqual(len(cmap), len(self._components))
cmap.clear()
self.assertEqual(len(cmap), 0)
def test_setdefault(self):
cmap = ComponentMap()
for c,_ in self._components:
with self.assertRaises(KeyError):
cmap[c]
self.assertTrue(c not in cmap)
cmap.setdefault(c, []).append(1)
self.assertEqual(cmap[c], [1])
del cmap[c]
with self.assertRaises(KeyError):
cmap[c]
self.assertTrue(c not in cmap)
cmap[c] = []
cmap.setdefault(c, []).append(1)
self.assertEqual(cmap[c], [1])
def test_eq(self):
cmap1 = ComponentMap()
self.assertNotEqual(cmap1, set())
self.assertFalse(cmap1 == set())
self.assertNotEqual(cmap1, list())
self.assertFalse(cmap1 == list())
self.assertNotEqual(cmap1, tuple())
self.assertFalse(cmap1 == tuple())
self.assertEqual(cmap1, dict())
self.assertTrue(cmap1 == dict())
cmap1.update(self._components)
self.assertNotEqual(cmap1, set())
self.assertFalse(cmap1 == set())
self.assertNotEqual(cmap1, list())
self.assertFalse(cmap1 == list())
self.assertNotEqual(cmap1, tuple())
self.assertFalse(cmap1 == tuple())
self.assertNotEqual(cmap1, dict())
self.assertFalse(cmap1 == dict())
self.assertTrue(cmap1 == cmap1)
self.assertEqual(cmap1, cmap1)
cmap2 = ComponentMap(self._components)
self.assertTrue(cmap2 == cmap1)
self.assertFalse(cmap2 != cmap1)
self.assertEqual(cmap2, cmap1)
self.assertTrue(cmap1 == cmap2)
self.assertFalse(cmap1 != cmap2)
self.assertEqual(cmap1, cmap2)
del cmap2[self._components[0][0]]
self.assertFalse(cmap2 == cmap1)
self.assertTrue(cmap2 != cmap1)
self.assertNotEqual(cmap2, cmap1)
self.assertFalse(cmap1 == cmap2)
self.assertTrue(cmap1 != cmap2)
self.assertNotEqual(cmap1, cmap2)
def test_active(self):
s = suffix()
with self.assertRaises(AttributeError):
s.active = False
model = block()
model.s = s
b = block()
b.model = model
bdict = block_dict()
bdict[0] = b
bdict[None] = block()
m = block()
m.bdict = bdict
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
m.deactivate(shallow=False)
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(s.active, False)
m.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
m.deactivate()
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
m.deactivate(shallow=False)
self.assertEqual(m.active, False)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(s.active, False)
m.activate()
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, False)
self.assertEqual(bdict[None].active, False)
self.assertEqual(b.active, False)
self.assertEqual(model.active, False)
self.assertEqual(s.active, False)
m.activate(shallow=False)
self.assertEqual(m.active, True)
self.assertEqual(bdict.active, True)
self.assertEqual(bdict[None].active, True)
self.assertEqual(b.active, True)
self.assertEqual(model.active, True)
self.assertEqual(s.active, True)
