def test_attribute_get_name_and_classifier(self):
m = CMetaclass("M", attributes={"isBoolean": True})
a = m.get_attribute("isBoolean")
eq_(a.name, "isBoolean")
eq_(a.classifier, m)
m.delete()
eq_(a.name, None)
eq_(a.classifier, None)
def test_super_metaclasses_that_are_deleted(self):
m1 = CMetaclass("M1")
m1.delete()
try:
CMetaclass(superclasses=[m1])
exception_expected_()
except CException as e:
eq_(e.value, "cannot access named element that has been deleted")
def test_extended_metaclass_that_is_deleted(self):
m1 = CMetaclass("M1")
m1.delete()
try:
CStereotype(extended=[m1])
exception_expected_()
except CException as e:
eq_(e.value, "cannot access named element that has been deleted")
def test_metaclass_is_deleted_in_constructor(self):
m1 = CMetaclass("M1")
m1.delete()
try:
CClass(m1, "C1")
exception_expected_()
except CException as e:
ok_(e.value.endswith("cannot access named element that has been deleted"))
def test_attribute_values_inheritance_after_delete_superclass(self):
t1 = CMetaclass("T1")
t2 = CMetaclass("T2")
c = CMetaclass("C", superclasses=[t1, t2])
sc = CMetaclass("C", superclasses=c)
t1.attributes = {"i0": 0}
t2.attributes = {"i1": 1}
c.attributes = {"i2": 2}
sc.attributes = {"i3": 3}
cl = CClass(sc, "C")
t2.delete()
for name, value in {"i0": 0, "i2": 2, "i3": 3}.items():
eq_(cl.get_value(name), value)
try:
cl.get_value("i1")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for 'C'")
eq_(cl.get_value("i0", t1), 0)
try:
cl.get_value("i1", t2)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for ''")
eq_(cl.get_value("i2", c), 2)
eq_(cl.get_value("i3", sc), 3)
for name, value in {"i0": 10, "i2": 12, "i3": 13}.items():
cl.set_value(name, value)
try:
cl.set_value("i1", 11)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for 'C'")
for name, value in {"i0": 10, "i2": 12, "i3": 13}.items():
eq_(cl.get_value(name), value)
try:
cl.get_value("i1")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for 'C'")
eq_(cl.get_value("i0", t1), 10)
try:
cl.get_value("i1", t2)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for ''")
eq_(cl.get_value("i2", c), 12)
eq_(cl.get_value("i3", sc), 13)
def test_delete_metaclass_having_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
m1 = CMetaclass("m1", bundles=[b1, b2])
m2 = CMetaclass("m2", bundles=[b2])
m1.delete()
eq_(set(b1.get_elements(type=CMetaclass)), set())
eq_(set(b2.get_elements(type=CMetaclass)), {m2})
eq_(set(m1.bundles), set())
eq_(set(m2.bundles), {b2})
def test_metaclass_is_deleted_in_metaclass_method(self):
m1 = CMetaclass("M1")
m2 = CMetaclass("M2")
c1 = CClass(m2, "C1")
m1.delete()
try:
c1.metaclass = m1
exception_expected_()
except CException as e:
ok_(e.value.endswith("cannot access named element that has been deleted"))
def test_default_values_from_stereotype__metaclass_delete(self):
mcl = CMetaclass("MCL",
attributes={
"aStr2": "def",
"aList2": ["d1", "d2"],
"b": bool
})
mcl2 = CMetaclass("MCL2",
superclasses=mcl,
attributes={
"aStr1": str,
"aList1": list
})
s1 = CStereotype("S1",
extended=mcl2,
default_values={
"aStr1": "a",
"aList2": []
})
s2 = CStereotype("S2",
superclasses=s1,
extended=mcl2,
default_values={
"aList1": ["a"],
"aStr2": "def2"
})
c1 = CClass(mcl2, "C1", stereotype_instances=s2)
mcl.delete()
c2 = CClass(mcl2, "C2", stereotype_instances=s1)
c3 = CClass(mcl2, "C3", stereotype_instances=s2)
eq_(c1.get_value("aStr1"), "a")
eq_(c1.get_value("aList1"), ["a"])
try:
eq_(c1.get_value("aStr2"), "def2")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'aStr2' unknown for 'C1'")
eq_(c2.get_value("aStr1"), "a")
eq_(c2.get_value("aList1"), None)
try:
eq_(c2.get_value("aStr2"), "def2")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'aStr2' unknown for 'C2'")
eq_(c3.get_value("aStr1"), "a")
eq_(c3.get_value("aList1"), ["a"])
try:
eq_(c3.get_value("aStr2"), "def2")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'aStr2' unknown for 'C3'")
def test_stereotype_remove_stereotype_or_metaclass(self):
mcl = CMetaclass("MCL1")
s1 = CStereotype("S1", extended=[mcl])
s2 = CStereotype("S2", extended=[mcl])
s3 = CStereotype("S3", extended=[mcl])
s4 = CStereotype("S4", extended=[mcl])
eq_(set(mcl.stereotypes), {s1, s2, s3, s4})
s2.delete()
eq_(set(mcl.stereotypes), {s1, s3, s4})
eq_(set(s2.extended), set())
eq_(set(s1.extended), {mcl})
mcl.delete()
eq_(set(mcl.stereotypes), set())
eq_(set(s1.extended), set())
def test_delete_metaclass_classes_relation(self):
m1 = CMetaclass()
m2 = CMetaclass()
cl1 = CClass(m1)
cl2 = CClass(m1)
cl3 = CClass(m2)
m1.delete()
eq_(cl1.metaclass, None)
eq_(cl2.metaclass, None)
eq_(cl3.metaclass, m2)
eq_(set(m2.classes), {cl3})
eq_(m1.classes, [])
def test_default_values_on_stereotype__metaclass_delete(self):
mcl = CMetaclass("MCL",
attributes={
"aStr2": "def",
"aList2": ["d1", "d2"],
"b": bool
})
mcl2 = CMetaclass("MCL2",
superclasses=mcl,
attributes={
"aStr1": str,
"aList1": list
})
s1 = CStereotype("S1",
extended=mcl2,
default_values={
"aStr1": "a",
"aList2": []
})
s2 = CStereotype("S2",
superclasses=s1,
extended=mcl2,
default_values={
"aList1": ["a"],
"aStr2": "def2"
})
mcl.delete()
eq_(s1.default_values, {"aStr1": "a"})
eq_(s2.default_values, {"aList1": ["a"]})
eq_(s1.get_default_value("aStr1"), "a")
try:
eq_(s2.get_default_value("aStr2"), "def2")
exception_expected_()
except CException as e:
eq_(
e.value,
"attribute 'aStr2' unknown for metaclasses extended by stereotype 'S2'"
)
eq_(s2.get_default_value("aStr1"), None)
def test_delete_metaclass(self):
m = CMetaclass("M1")
cl = CClass(m, "C")
m.delete()
eq_(cl.metaclass, None)
m1 = CMetaclass("M1")
m2 = CMetaclass("M2")
m3 = CMetaclass("M3",
superclasses=m2,
attributes={"i": 1},
stereotypes=CStereotype("S"))
cl = CClass(m3, "C")
m1.delete()
eq_(cl.metaclass, m3)
m3.delete()
eq_(cl.metaclass, None)
eq_(m3.superclasses, [])
eq_(m2.subclasses, [])
eq_(m3.attributes, [])
eq_(m3.attribute_names, [])
eq_(m3.stereotypes, [])
eq_(m3.classes, [])
eq_(m3.name, None)
eq_(m3.bundles, [])
def test_metaclass_inheritance_delete_top_class(self):
t = CMetaclass("T")
m1 = CMetaclass("M1", superclasses=[t])
m2 = CMetaclass("M2", superclasses=[t])
b1 = CMetaclass("B1", superclasses=[m1])
b2 = CMetaclass("B2", superclasses=[m1])
b3 = CMetaclass("B3", superclasses=[t])
t.delete()
eq_(t.name, None)
eq_(set(t.superclasses), set())
eq_(set(t.subclasses), set())
eq_(set(t.all_superclasses), set())
eq_(set(t.all_subclasses), set())
eq_(set(m1.superclasses), set())
eq_(set(m1.subclasses), {b1, b2})
eq_(set(m1.all_superclasses), set())
eq_(set(m1.all_subclasses), {b1, b2})
eq_(set(m2.superclasses), set())
eq_(set(m2.subclasses), set())
eq_(set(m2.all_superclasses), set())
eq_(set(m2.all_subclasses), set())
eq_(set(b1.superclasses), {m1})
eq_(set(b1.subclasses), set())
eq_(set(b1.all_superclasses), {m1})
eq_(set(b1.all_subclasses), set())
eq_(set(b2.superclasses), {m1})
eq_(set(b2.subclasses), set())
eq_(set(b2.all_superclasses), {m1})
eq_(set(b2.all_subclasses), set())
eq_(set(b3.superclasses), set())
eq_(set(b3.subclasses), set())
eq_(set(b3.all_superclasses), set())
eq_(set(b3.all_subclasses), set())
def test_metaclass_inheritance_delete_inner_class(self):
t = CMetaclass("T")
m1 = CMetaclass("M1", superclasses=[t])
m2 = CMetaclass("M2", superclasses=[t])
b1 = CMetaclass("B1", superclasses=[m1])
b2 = CMetaclass("B2", superclasses=[m1])
b3 = CMetaclass("B3", superclasses=[t])
m1.delete()
eq_(set(t.superclasses), set())
eq_(set(t.subclasses), {m2, b3})
eq_(set(t.all_superclasses), set())
eq_(set(t.all_subclasses), {m2, b3})
eq_(set(m1.superclasses), set())
eq_(set(m1.subclasses), set())
eq_(set(m1.all_superclasses), set())
eq_(set(m1.all_subclasses), set())
eq_(set(m2.superclasses), {t})
eq_(set(m2.subclasses), set())
eq_(set(m2.all_superclasses), {t})
eq_(set(m2.all_subclasses), set())
eq_(set(b1.superclasses), set())
eq_(set(b1.subclasses), set())
eq_(set(b1.all_superclasses), set())
eq_(set(b1.all_subclasses), set())
eq_(set(b2.superclasses), set())
eq_(set(b2.subclasses), set())
eq_(set(b2.all_superclasses), set())
eq_(set(b2.all_subclasses), set())
eq_(set(b3.superclasses), {t})
eq_(set(b3.subclasses), set())
eq_(set(b3.all_superclasses), {t})
eq_(set(b3.all_subclasses), set())
def test_delete_metaclass_from_bundle(self):
b1 = CBundle("B1")
CBundle("B2")
m1 = CMetaclass("M1", bundles=b1)
m1.delete()
eq_(set(b1.get_elements(type=CMetaclass)), set())
m1 = CMetaclass("M1", bundles=b1)
m2 = CMetaclass("M1", bundles=b1)
m3 = CMetaclass("M1", superclasses=m2, attributes={"i": 1}, bundles=b1)
CClass(m3, bundles=b1)
m1.delete()
eq_(set(b1.get_elements(type=CMetaclass)), {m2, m3})
m3.delete()
eq_(set(b1.get_elements(type=CMetaclass)), {m2})
eq_(m3.superclasses, [])
eq_(m2.subclasses, [])
eq_(m3.attributes, [])
eq_(m3.attribute_names, [])
eq_(m3.classes, [])
eq_(m3.name, None)
eq_(m3.bundles, [])
eq_(b1.get_elements(type=CClass), [])
class TestMetaclassAssociations:
def setup(self):
self.metaclassBundle = CBundle("P")
self.m1 = CMetaclass("M1", bundles=self.metaclassBundle)
self.m2 = CMetaclass("M2", bundles=self.metaclassBundle)
self.m3 = CMetaclass("M3", bundles=self.metaclassBundle)
self.m4 = CMetaclass("M4", bundles=self.metaclassBundle)
self.m5 = CMetaclass("M5", bundles=self.metaclassBundle)
def get_all_associations_in_bundle(self):
associations = []
for c in self.metaclassBundle.get_elements(type=CMetaclass):
for a in c.all_associations:
if a not in associations:
associations.append(a)
return associations
def test_association_creation(self):
a1 = self.m1.association(self.m2,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
a2 = self.m1.association(self.m2, "[o]*->[s]1")
a3 = self.m1.association(self.m3, "[a] 0..1 <*>- [n]*")
a4 = self.m1.association(self.m3,
multiplicity="*",
role_name="e",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a5 = self.m4.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
aggregation=True)
a6 = self.m3.association(self.m2, '[a] 3 <>- [e]*')
eq_(len(self.get_all_associations_in_bundle()), 6)
eq_(self.m1.associations[0].role_name, "t")
eq_(a5.role_name, "n")
eq_(a2.role_name, "s")
eq_(a1.multiplicity, "1")
eq_(a1.source_multiplicity, "*")
eq_(a4.source_multiplicity, "0..1")
eq_(a6.source_multiplicity, "3")
eq_(a1.composition, False)
eq_(a1.aggregation, False)
eq_(a3.composition, True)
eq_(a3.aggregation, False)
eq_(a5.composition, False)
eq_(a5.aggregation, True)
a1.aggregation = True
eq_(a1.composition, False)
eq_(a1.aggregation, True)
a1.composition = True
eq_(a1.composition, True)
eq_(a1.aggregation, False)
def test_mixed_association_types(self):
c1 = CClass(self.m1, "C1")
s1 = CStereotype("S1")
try:
self.m1.association(s1,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
exception_expected_()
except CException as e:
eq_(
"metaclass 'M1' is not compatible with association target 'S1'",
e.value)
try:
self.m1.association(c1,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
exception_expected_()
except CException as e:
eq_(
"metaclass 'M1' is not compatible with association target 'C1'",
e.value)
def test_get_association_by_role_name(self):
self.m1.association(self.m2,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
self.m1.association(self.m2,
multiplicity="1",
role_name="s",
source_multiplicity="*",
source_role_name="o")
self.m1.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a_2 = next(a for a in self.m1.associations if a.role_name == "s")
eq_(a_2.multiplicity, "1")
eq_(a_2.source_role_name, "o")
eq_(a_2.source_multiplicity, "*")
def test_get_association_by_name(self):
self.m1.association(self.m2,
name="n1",
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
self.m1.association(self.m2,
name="n2",
multiplicity="1",
role_name="s",
source_multiplicity="*",
source_role_name="o")
self.m1.association(self.m3, "n3: [a] 0..1 <*>- [n] *")
a_2 = next(a for a in self.m1.associations if a.name == "n2")
eq_(a_2.multiplicity, "1")
eq_(a_2.source_role_name, "o")
eq_(a_2.source_multiplicity, "*")
a_3 = next(a for a in self.m1.associations if a.name == "n3")
eq_(a_3.multiplicity, "*")
eq_(a_3.role_name, "n")
eq_(a_3.source_multiplicity, "0..1")
eq_(a_3.source_role_name, "a")
eq_(a_3.composition, True)
def test_get_associations(self):
a1 = self.m1.association(self.m2,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
a2 = self.m1.association(self.m2,
multiplicity="1",
role_name="s",
source_multiplicity="*",
source_role_name="o")
a3 = self.m1.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a4 = self.m1.association(self.m3,
multiplicity="*",
role_name="e",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a5 = self.m4.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
aggregation=True)
a6 = self.m3.association(self.m2,
multiplicity="*",
role_name="e",
source_multiplicity="3",
source_role_name="a",
aggregation=True)
eq_(self.m1.associations, [a1, a2, a3, a4])
eq_(self.m2.associations, [a1, a2, a6])
eq_(self.m3.associations, [a3, a4, a5, a6])
eq_(self.m4.associations, [a5])
eq_(self.m5.associations, [])
def test_delete_associations(self):
a1 = self.m1.association(self.m2,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
a2 = self.m1.association(self.m2,
multiplicity="1",
role_name="s",
source_multiplicity="*",
source_role_name="o")
a3 = self.m1.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a4 = self.m1.association(self.m3,
multiplicity="*",
role_name="e",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a5 = self.m4.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
aggregation=True)
a6 = self.m3.association(self.m2,
multiplicity="*",
role_name="e",
source_multiplicity="3",
source_role_name="a",
aggregation=True)
a7 = self.m1.association(self.m1,
multiplicity="*",
role_name="x",
source_multiplicity="3",
source_role_name="y")
eq_(len(self.get_all_associations_in_bundle()), 7)
a2.delete()
a4.delete()
eq_(len(self.get_all_associations_in_bundle()), 5)
eq_(self.m1.associations, [a1, a3, a7])
eq_(self.m2.associations, [a1, a6])
eq_(self.m3.associations, [a3, a5, a6])
eq_(self.m4.associations, [a5])
eq_(self.m5.associations, [])
def test_delete_class_and_get_associations(self):
self.m1.association(self.m2,
multiplicity="1",
role_name="t",
source_multiplicity="*",
source_role_name="i")
self.m1.association(self.m2,
multiplicity="1",
role_name="s",
source_multiplicity="*",
source_role_name="o")
self.m1.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
self.m1.association(self.m3,
multiplicity="*",
role_name="e",
source_multiplicity="0..1",
source_role_name="a",
composition=True)
a5 = self.m4.association(self.m3,
multiplicity="*",
role_name="n",
source_multiplicity="0..1",
source_role_name="a",
aggregation=True)
a6 = self.m3.association(self.m2,
multiplicity="*",
role_name="e",
source_multiplicity="3",
source_role_name="a",
aggregation=True)
self.m1.association(self.m1,
multiplicity="*",
role_name="x",
source_multiplicity="3",
source_role_name="y")
eq_(len(self.get_all_associations_in_bundle()), 7)
self.m1.delete()
eq_(len(self.get_all_associations_in_bundle()), 2)
eq_(self.m1.associations, [])
eq_(self.m2.associations, [a6])
eq_(self.m3.associations, [a5, a6])
eq_(self.m4.associations, [a5])
eq_(self.m5.associations, [])
def test_all_associations(self):
s = CMetaclass("S")
d = CMetaclass("D", superclasses=s)
a = s.association(d, "is next: [prior s] * -> [next d] *")
eq_(d.all_associations, [a])
eq_(s.all_associations, [a])
def test_get_opposite_classifier(self):
a = self.m1.association(self.m2, "[o]*->[s]1")
eq_(a.get_opposite_classifier(self.m1), self.m2)
eq_(a.get_opposite_classifier(self.m2), self.m1)
try:
a.get_opposite_classifier(self.m3)
exception_expected_()
except CException as e:
eq_(
"can only get opposite if either source or target classifier is provided",
e.value)
