def test_specific_n_to_n_link_multiplicity(self):
a = self.c1.association(self.c2,
name="l",
source_multiplicity="1..2",
multiplicity="2")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c2, "o2")
o3 = CObject(self.c2, "o3")
o4 = CObject(self.c1, "o4")
o5 = CObject(self.c1, "o5")
o6 = CObject(self.c2, "o6")
try:
set_links({o1: []}, association=a)
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '0': should be '2'"
)
try:
set_links({o1: [o2]}, association=a)
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '1': should be '2'"
)
try:
set_links({o1: [o2, o3, o6]}, association=a)
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '3': should be '2'"
)
set_links({o1: [o2, o3]})
eq_(o1.get_linked(association=a), [o2, o3])
set_links({o2: [o1, o4], o1: o3, o4: o3})
eq_(o2.get_linked(association=a), [o1, o4])
try:
set_links({o2: []}, association=a)
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o2' have wrong multiplicity '0': should be '1..2'"
)
try:
set_links({o2: [o1, o4, o5]})
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o2' have wrong multiplicity '3': should be '1..2'"
)
def test_link_with_inheritance_in_classifier_targets_using_role_names(
self):
sub_class = CClass(self.mcl, superclasses=self.c2)
a1 = self.c1.association(sub_class, "a1: * -> [sub_class] *")
a2 = self.c1.association(self.c2, "a2: * -> [c2] *")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c1, "o2")
o_sub_1 = CObject(sub_class, "o_sub_1")
o_sub_2 = CObject(sub_class, "o_sub_2")
o_super_1 = CObject(self.c2, "o_super_1")
o_super_2 = CObject(self.c2, "o_super_2")
set_links({o1: [o_sub_1, o_sub_2]}, role_name="sub_class")
set_links({o1: [o_sub_1]}, role_name="c2")
set_links({o2: [o_super_1, o_super_2]})
eq_(o1.linked, [o_sub_1, o_sub_2, o_sub_1])
eq_(o1.get_linked(), [o_sub_1, o_sub_2, o_sub_1])
eq_(o2.get_linked(), [o_super_1, o_super_2])
eq_(o1.get_linked(association=a1), [o_sub_1, o_sub_2])
eq_(o1.get_linked(association=a2), [o_sub_1])
eq_(o2.get_linked(association=a1), [])
eq_(o2.get_linked(association=a2), [o_super_1, o_super_2])
eq_(o1.get_linked(role_name="sub_class"), [o_sub_1, o_sub_2])
eq_(o1.get_linked(role_name="c2"), [o_sub_1])
eq_(o2.get_linked(role_name="sub_class"), [])
eq_(o2.get_linked(role_name="c2"), [o_super_1, o_super_2])
def test_set_links_multiple_links_in_definition(self):
self.c1.association(self.c2, "[sourceRole1] * -> [role1] *")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c1, "o2")
o3 = CObject(self.c1, "o3")
o4 = CObject(self.c2, "o4")
o5 = CObject(self.c2, "o5")
set_links({o1: o4, o2: [o4], o5: [o1, o2, o3]})
eq_(o1.get_linked(), [o4, o5])
eq_(o2.get_linked(), [o4, o5])
eq_(o3.get_linked(), [o5])
eq_(o4.get_linked(), [o1, o2])
eq_(o5.get_linked(), [o1, o2, o3])
def test_duplicate_assignment(self):
a = self.c1.association(self.c2, "l: *->*")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c2, "o2")
try:
set_links({o1: [o2, o2]})
exception_expected_()
except CException as e:
eq_(
e.value,
"trying to link the same link twice 'o1 -> o2'' twice for the same association"
)
eq_(o1.get_linked(), [])
eq_(o2.get_linked(), [])
b = self.c1.association(self.c2, "l: *->*")
o1.add_links(o2, association=a)
o1.add_links(o2, association=b)
eq_(o1.get_linked(), [o2, o2])
eq_(o2.get_linked(), [o1, o1])
def test_link_and_get_links_by_association(self):
a1 = self.c1.association(self.c2, name="a1", multiplicity="*")
a2 = self.c1.association(self.c2, name="a2", multiplicity="*")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c2, "o2")
o3 = CObject(self.c2, "o3")
links_a1 = set_links({o1: o2}, association=a1)
links_a2 = set_links({o1: [o2, o3]}, association=a2)
eq_(o1.get_linked(), [o2, o2, o3])
eq_(o1.linked, [o2, o2, o3])
eq_(o1.get_linked(association=a1), [o2])
eq_(o1.get_linked(association=a2), [o2, o3])
eq_(o1.get_links_for_association(a1), links_a1)
eq_(o1.get_links_for_association(a2), links_a2)
def test_add_links(self):
self.c1.association(self.c2, "1 -> [role1] *")
self.c1.association(self.c2, "* -> [role2] *")
self.c1.association(self.c2, "1 -> [role3] 1")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c2, "o2")
o3 = CObject(self.c2, "o3")
o4 = CObject(self.c2, "o4")
add_links({o1: o2}, role_name="role1")
eq_(o1.get_linked(role_name="role1"), [o2])
add_links({o1: [o3, o4]}, role_name="role1")
o1.get_linked(role_name="role1")
eq_(o1.get_linked(role_name="role1"), [o2, o3, o4])
o1.add_links(o2, role_name="role2")
eq_(o1.get_linked(role_name="role2"), [o2])
o1.add_links([o3, o4], role_name="role2")
o1.get_linked(role_name="role2")
eq_(o1.get_linked(role_name="role2"), [o2, o3, o4])
add_links({o1: o2}, role_name="role3")
eq_(o1.get_linked(role_name="role3"), [o2])
try:
add_links({o1: [o3, o4]}, role_name="role3")
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '3': should be '1'"
)
try:
add_links({o1: [o3]}, role_name="role3")
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '2': should be '1'"
)
eq_(o1.get_linked(role_name="role3"), [o2])
def test_link_methods_wrong_keyword_args(self):
o1 = CObject(self.c1, "o1")
try:
add_links({o1: o1}, associationX=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
o1.add_links(o1, associationX=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
set_links({o1: o1}, associationX=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
delete_links({o1: o1}, associationX=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
o1.delete_links(o1, associationX=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
o1.get_linked(associationX=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
delete_links({o1: o1}, stereotype_instances=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
try:
delete_links({o1: o1}, tagged_values=None)
exception_expected_()
except CException as e:
eq_(e.value, "unknown keywords argument")
def test_add_links_source_multiplicity(self):
self.c1.association(self.c2, "[sourceRole1] 1 -> [role1] *")
self.c1.association(self.c2, "[sourceRole2] 1 -> [role2] 1")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c1, "o2")
o3 = CObject(self.c2, "o3")
o4 = CObject(self.c2, "o4")
o5 = CObject(self.c2, "o5")
o6 = CObject(self.c2, "o6")
add_links({o2: o3}, role_name="role1")
add_links({o2: o4}, role_name="role1")
eq_(o3.get_linked(role_name="sourceRole1"), [o2])
add_links({o2: o5}, role_name="role1")
eq_(o2.get_linked(role_name="role1"), [o3, o4, o5])
try:
add_links({o1: [o4]}, role_name="role1")
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o4' have wrong multiplicity '2': should be '1'"
)
add_links({o1: o6}, role_name="role2")
eq_(o1.get_linked(role_name="role2"), [o6])
try:
add_links({o1: [o3, o4]}, role_name="role2")
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '3': should be '1'"
)
eq_(o1.get_linked(role_name="role2"), [o6])
def test_link_source_multiplicity(self):
self.c1.association(self.c2, "[sourceRole1] 1 -> [role1] *")
self.c1.association(self.c2, "[sourceRole2] 1 -> [role2] 1")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c1, "o2")
o3 = CObject(self.c2, "o3")
CObject(self.c2, "o4")
CObject(self.c2, "o5")
set_links({o1: o3}, role_name="role1")
set_links({o2: o3}, role_name="role1")
eq_(o3.get_linked(role_name="sourceRole1"), [o2])
def test_link_with_inheritance_in_classifier_targets(self):
sub_class = CClass(self.mcl, superclasses=self.c2)
a1 = self.c1.association(sub_class, name="a1", multiplicity="*")
a2 = self.c1.association(self.c2, name="a2", multiplicity="*")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c1, "o2")
o_sub_1 = CObject(sub_class, "o_sub_1")
o_sub_2 = CObject(sub_class, "o_sub_2")
o_super_1 = CObject(self.c2, "o_super_1")
o_super_2 = CObject(self.c2, "o_super_2")
try:
# ambiguous, list works for both associations
set_links({o1: [o_sub_1, o_sub_2]})
exception_expected_()
except CException as e:
eq_(
e.value,
"link specification ambiguous, multiple matching associations "
+ "found for source 'o1' and targets '['o_sub_1', 'o_sub_2']'")
set_links({o1: [o_sub_1, o_sub_2]}, association=a1)
set_links({o1: [o_sub_1]}, association=a2)
set_links({o2: [o_super_1, o_super_2]})
eq_(o1.linked, [o_sub_1, o_sub_2, o_sub_1])
eq_(o1.get_linked(), [o_sub_1, o_sub_2, o_sub_1])
eq_(o2.get_linked(), [o_super_1, o_super_2])
eq_(o1.get_linked(association=a1), [o_sub_1, o_sub_2])
eq_(o1.get_linked(association=a2), [o_sub_1])
eq_(o2.get_linked(association=a1), [])
eq_(o2.get_linked(association=a2), [o_super_1, o_super_2])
# this mixed list is applicable only for a2
set_links({o2: [o_sub_1, o_super_1]})
eq_(o2.get_linked(association=a1), [])
eq_(o2.get_linked(association=a2), [o_sub_1, o_super_1])
def test_add_links_with_inherited_common_classifiers(self):
mcl = CMetaclass("MCL")
super_a = CClass(mcl, "SuperA")
super_b = CClass(mcl, "SuperB")
super_a.association(super_b, "[a] 1 -> [b] *")
sub_b1 = CClass(mcl, "SubB1", superclasses=[super_b])
sub_b2 = CClass(mcl, "SubB2", superclasses=[super_b])
sub_a = CClass(mcl, "SubA", superclasses=[super_a])
obj_a = CObject(sub_a, "a")
obj_b1 = CObject(sub_b1, "b1")
obj_b2 = CObject(sub_b2, "b2")
add_links({obj_a: [obj_b1, obj_b2]}, role_name="b")
eq_(set(obj_a.get_linked(role_name="b")), {obj_b1, obj_b2})
def test_one_to_n_link_multiplicity(self):
a = self.c1.association(self.c2,
name="l",
source_multiplicity="1",
multiplicity="1..*")
o1 = CObject(self.c1, "o1")
o2 = CObject(self.c2, "o2")
o3 = CObject(self.c2, "o3")
o4 = CObject(self.c1, "o4")
try:
set_links({o1: []}, association=a)
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o1' have wrong multiplicity '0': should be '1..*'"
)
set_links({o1: [o2, o3]})
eq_(o1.get_linked(association=a), [o2, o3])
try:
set_links({o2: []}, association=a)
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o2' have wrong multiplicity '0': should be '1'"
)
try:
set_links({o2: [o1, o4]})
exception_expected_()
except CException as e:
eq_(
e.value,
"links of object 'o2' have wrong multiplicity '2': should be '1'"
)
def test_n_to_n_set_self_link_delete_links(self):
self.c1.association(self.c1,
name="a",
source_multiplicity="*",
multiplicity="*",
source_role_name="super",
role_name="sub")
top = CObject(self.c1, "Top")
mid1 = CObject(self.c1, "Mid1")
mid2 = CObject(self.c1, "Mid2")
mid3 = CObject(self.c1, "Mid3")
bottom1 = CObject(self.c1, "Bottom1")
bottom2 = CObject(self.c1, "Bottom2")
set_links({
top: [mid1, mid2, mid3],
mid1: [bottom1, bottom2]
},
role_name="sub")
# delete links
set_links({top: []}, role_name="sub")
eq_(top.linked, [])
eq_(mid1.linked, [bottom1, bottom2])
# change links
set_links({
mid1: top,
mid3: top,
bottom1: mid1,
bottom2: mid1
},
role_name="super")
eq_(top.linked, [mid1, mid3])
eq_(mid1.linked, [top, bottom1, bottom2])
eq_(mid2.linked, [])
eq_(mid3.linked, [top])
eq_(bottom1.linked, [mid1])
eq_(bottom2.linked, [mid1])
eq_(top.get_linked(role_name="sub"), [mid1, mid3])
eq_(mid1.get_linked(role_name="sub"), [bottom1, bottom2])
eq_(mid2.get_linked(role_name="sub"), [])
eq_(mid3.get_linked(role_name="sub"), [])
eq_(bottom1.get_linked(role_name="sub"), [])
eq_(bottom2.get_linked(role_name="sub"), [])
eq_(top.get_linked(role_name="super"), [])
eq_(mid1.get_linked(role_name="super"), [top])
eq_(mid2.get_linked(role_name="super"), [])
eq_(mid3.get_linked(role_name="super"), [top])
eq_(bottom1.get_linked(role_name="super"), [mid1])
eq_(bottom2.get_linked(role_name="super"), [mid1])
class TestLinkObjectsForClasses:
def setup(self):
self.mcl = CMetaclass("MCL")
self.cl = CClass(self.mcl, "CL")
def test_reference_to_link(self):
code = CClass(self.mcl, "Code")
source = CClass(self.mcl, "Source")
code_association = code.association(
source, "[contained_code] * -> [source] *")
code_a = CClass(self.mcl, "Code A", superclasses=code)
code_b = CClass(self.mcl, "Code B", superclasses=code)
a_b_association = code_a.association(code_b,
"a_b: [code_a] * -> [code_b] *",
superclasses=code)
source_1 = CObject(source, "source_1")
code_a1 = CObject(code_a, "code_a1")
code_b1 = CObject(code_b, "code_b1")
code_b2 = CObject(code_b, "code_b2")
code_b3 = CObject(code_b, "code_b3")
a_b_links = add_links({code_a1: [code_b1, code_b2]},
association=a_b_association)
code_links = add_links(
{
source_1:
[code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]]
},
role_name="contained_code")
eq_(len(code_links), 5)
# test getter methods on object
eq_(set(source_1.get_linked(role_name="contained_code")),
{code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]})
eq_(set(source_1.linked),
{code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]})
eq_(set(source_1.links), set(code_links))
eq_(set(source_1.get_links_for_association(code_association)),
set(code_links))
eq_(set(get_links([source_1])), set(code_links))
# test getter methods on link
eq_(a_b_links[0].get_linked(role_name="source"), [source_1])
eq_(a_b_links[0].linked, [source_1])
eq_(a_b_links[0].links, [code_links[3]])
eq_(a_b_links[0].get_links_for_association(code_association),
[code_links[3]])
eq_(set(get_links([a_b_links[0]])), {code_links[3]})
eq_(
set(get_links([code_a1, a_b_links[0], a_b_links[1]])), {
code_links[0], a_b_links[0], a_b_links[1], code_links[3],
code_links[4]
})
# test add/delete links
code_b3_link = code_a1.add_links(code_b3)[0]
source_1.add_links(code_b3_link)
eq_(set(code_a1.linked), {code_b1, code_b2, source_1, code_b3})
eq_(set(source_1.linked), {
code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1], code_b3_link
})
eq_(code_b3_link.linked, [source_1])
a_b_links[1].delete_links([source_1])
eq_(set(source_1.linked),
{code_a1, code_b2, code_b1, a_b_links[0], code_b3_link})
source_1.delete_links([code_a1, a_b_links[0]])
eq_(set(source_1.linked), {code_b2, code_b1, code_b3_link})
# test whether metaclass links fail on class
mcl_a = CMetaclass("M")
mcl_b = CMetaclass("Source")
mcl_association = mcl_a.association(mcl_b, "[a] * -> [b] *")
cl_a = CClass(mcl_a, "cla")
cl_b = CClass(mcl_a, "clb")
class_link = add_links({cl_a: [cl_b]}, association=mcl_association)[0]
try:
add_links({source_1: [code_a1, code_b2, code_b1, class_link]},
role_name="contained_code")
exception_expected_()
except CException as e:
eq_("link target is a class link, but source is an object",
e.value)
def test_link_association_has_a_compatible_superclass(self):
code = CClass(self.mcl, "Code")
source = CClass(self.mcl, "Source")
code.association(source, "[contained_code] * -> [source] *")
code_a = CClass(self.mcl, "Code A", superclasses=code)
code_b = CClass(self.mcl, "Code B", superclasses=code)
a_b_association = code_a.association(code_b,
"a_b: [code_a] * -> [code_b] *")
source_1 = CObject(source, "source_1")
code_a1 = CObject(code_a, "code_a1")
code_b1 = CObject(code_b, "code_b1")
code_b2 = CObject(code_b, "code_b2")
links = add_links({code_a1: [code_b1, code_b2]},
association=a_b_association)
try:
add_links(
{source_1: [code_a1, code_b2, code_b1, links[0], links[1]]},
role_name="contained_code")
exception_expected_()
except CException as e:
eq_("the link's association is missing a compatible classifier",
e.value)
a_b_association.superclasses = self.cl
try:
add_links(
{source_1: [code_a1, code_b2, code_b1, links[0], links[1]]},
role_name="contained_code")
exception_expected_()
except CException as e:
eq_("the link's association is missing a compatible classifier",
e.value)
a_b_association.superclasses = code_b
add_links({source_1: [code_a1, code_b2, code_b1, links[0], links[1]]},
role_name="contained_code")
def test_association_to_association_not_possible(self):
clx = CClass(self.mcl, "X")
cla = CClass(self.mcl, "A")
clb = CClass(self.mcl, "B")
a_b_association = cla.association(clb, "a_b: [a] * -> [b] *")
try:
clx.association(a_b_association, "[x] * -> [a_b_association] *")
exception_expected_()
except CException as e:
eq_("class 'X' is not compatible with association target 'a_b'",
e.value)
def test_link_to_link(self):
collection1 = CClass(self.mcl, "Collection1")
collection2 = CClass(self.mcl, "Collection2")
collections_association = collection1.association(
collection2,
"element references: [references] * -> [referenced] *")
type_a = CClass(self.mcl, "Type A", superclasses=collection1)
type_b = CClass(self.mcl, "Type B", superclasses=collection1)
a_b_association = type_a.association(type_b,
"a_b: [type_a] * -> [type_b] *",
superclasses=collection1)
type_c = CClass(self.mcl, "Type C", superclasses=collection2)
type_d = CClass(self.mcl,
"Type D",
superclasses=[collection1, collection2])
c_d_association = type_c.association(type_d,
"c_d: [type_c] * -> [type_d] *",
superclasses=collection2)
a_d_association = type_a.association(
type_d,
"a_d: [type_a] * -> [type_d] *",
superclasses=[collection1, collection2])
a1 = CObject(type_a, "a1")
b1 = CObject(type_b, "b1")
b2 = CObject(type_b, "b2")
c1 = CObject(type_c, "c1")
c2 = CObject(type_c, "c2")
d1 = CObject(type_d, "d1")
a_b_links = add_links({a1: [b1, b2]}, association=a_b_association)
c_d_links = add_links({d1: [c1, c2]}, association=c_d_association)
a_d_links = add_links({a1: [d1]}, association=a_d_association)
references_links = add_links(
{
a_b_links[0]: c_d_links[0],
a_b_links[1]: [c1, c2, d1, c_d_links[1], c_d_links[0]],
a_d_links[0]: [a_d_links[0], c_d_links[1], c1, d1]
},
role_name="referenced")
eq_(set(a_b_links[0].get_linked(role_name="referenced")),
{c_d_links[0]})
eq_(set(a_b_links[0].linked), {c_d_links[0]})
eq_(set(a_b_links[0].links), {references_links[0]})
eq_(
set(a_b_links[0].get_links_for_association(
collections_association)), {references_links[0]})
eq_(set(get_links([a_b_links[0]])), {references_links[0]})
eq_(set(a_b_links[1].get_linked(role_name="referenced")),
{c1, c2, d1, c_d_links[1], c_d_links[0]})
eq_(set(a_b_links[1].linked), {c1, c2, d1, c_d_links[1], c_d_links[0]})
correct_links_set = {
references_links[1], references_links[2], references_links[3],
references_links[4], references_links[5]
}
eq_(set(a_b_links[1].links), correct_links_set)
eq_(
set(a_b_links[1].get_links_for_association(
collections_association)), correct_links_set)
eq_(set(get_links([a_b_links[1]])), correct_links_set)
eq_(set(a_d_links[0].get_linked(role_name="referenced")),
{a_d_links[0], c_d_links[1], c1, d1})
eq_(set(a_d_links[0].linked), {a_d_links[0], c_d_links[1], c1, d1})
correct_links_set = {
references_links[6], references_links[7], references_links[8],
references_links[9]
}
eq_(set(a_d_links[0].links), correct_links_set)
eq_(
set(a_d_links[0].get_links_for_association(
collections_association)), correct_links_set)
eq_(set(get_links([a_d_links[0]])), correct_links_set)
def test_links_as_attribute_values(self):
code = CClass(self.mcl, "Code")
source = CClass(self.mcl, "Source")
code.association(source, "[contained_code] * -> [source] *")
code_a = CClass(self.mcl, "Code A", superclasses=code)
code_b = CClass(self.mcl, "Code B", superclasses=code)
a_b_association = code_a.association(code_b,
"a_b: [code_a] * -> [code_b] *",
superclasses=code)
code_a1 = CObject(code_a, "code_a1")
code_b1 = CObject(code_b, "code_b1")
code_b2 = CObject(code_b, "code_b2")
a_b_links = add_links({code_a1: [code_b1, code_b2]},
association=a_b_association)
links_list = [code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]]
collection_type = CClass(self.mcl,
"Collection Type",
attributes={
"primary_code": code,
"default_value_code": a_b_links[0],
"codes": list,
"default_values_list": links_list
})
collection = CObject(collection_type)
eq_(collection.get_value("primary_code"), None)
eq_(collection.get_value("default_value_code"), a_b_links[0])
eq_(collection.get_value("codes"), None)
eq_(collection.get_value("default_values_list"), links_list)
collection.set_value("primary_code", a_b_links[1])
collection.set_value("default_value_code", a_b_links[1])
collection.set_value("codes", [code_a1, a_b_links[0]])
collection.set_value("default_values_list",
[a_b_links[0], a_b_links[1]])
eq_(collection.get_value("primary_code"), a_b_links[1])
eq_(collection.get_value("default_value_code"), a_b_links[1])
eq_(collection.get_value("codes"), [code_a1, a_b_links[0]])
eq_(collection.get_value("default_values_list"),
[a_b_links[0], a_b_links[1]])
collection.values = {
'default_values_list': [a_b_links[0]],
"codes": []
}
eq_(
collection.values, {
'default_value_code': a_b_links[1],
'default_values_list': [a_b_links[0]],
'codes': [],
'primary_code': a_b_links[1]
})
collection.delete_value("primary_code")
collection.delete_value("default_value_code")
collection.delete_value("codes")
collection.delete_value("default_values_list")
eq_(collection.get_value("primary_code"), None)
eq_(collection.get_value("default_value_code"), None)
eq_(collection.get_value("codes"), None)
eq_(collection.get_value("default_values_list"), None)
def create_simple_link_object_test_setup(self):
self.a = CClass(self.mcl, "A")
self.a1 = CClass(self.mcl, "A1", superclasses=self.a)
self.a2 = CClass(self.mcl, "A2", superclasses=self.a)
self.a_association = self.a1.association(self.a2,
"[a1] * -> [a2] *",
superclasses=self.a)
self.b = CClass(self.mcl, "B")
self.b_a_association = self.b.association(self.a, "[b] * -> [a] *")
self.a1_1 = CObject(self.a1, "a1_1")
self.a1_2 = CObject(self.a1, "a1_2")
self.a2_1 = CObject(self.a2, "a2_1")
self.b_1 = CObject(self.b, "b_1")
self.a_links = add_links({self.a2_1: [self.a1_1, self.a1_2]},
association=self.a_association)
self.b_a_links = add_links(
{self.b_1: [self.a_links[0], self.a_links[1]]},
association=self.b_a_association)
def test_attributes_on_association_classifier(self):
self.create_simple_link_object_test_setup()
eq_(self.b_a_association.attributes, [])
eq_(self.b_a_association.attribute_names, [])
try:
self.b_a_association.attributes = {
"i1": int,
"i2": 15,
"s1": str,
"s2": "abc"
}
exception_expected_()
except CException as e:
eq_("setting of attributes not supported for associations",
e.value)
eq_(self.b_a_association.get_attribute("i1"), None)
def test_superclass_sub_class_method_on_association_classifier(self):
self.create_simple_link_object_test_setup()
eq_(self.a_association.superclasses, [self.a])
eq_(self.a_association.subclasses, [])
eq_(self.b_a_association.superclasses, [])
eq_(self.b_a_association.subclasses, [])
eq_(self.a.subclasses, [self.a1, self.a2, self.a_association])
try:
another_sc = CMetaclass("ASC")
self.a_association.superclasses = [self.a, another_sc]
exception_expected_()
except CException as e:
eq_(
"cannot add superclass 'ASC': not a class or class association",
e.value)
try:
another_sc = CStereotype("ASC")
self.a_association.superclasses = [self.a, another_sc]
exception_expected_()
except CException as e:
eq_(
"cannot add superclass 'ASC': not a class or class association",
e.value)
another_sc = CClass(self.mcl, "ASC")
self.a_association.superclasses = [self.a, another_sc]
eq_(self.a_association.superclasses, [self.a, another_sc])
eq_(set(self.a_association.all_superclasses), {self.a, another_sc})
a2_association = self.a1.association(self.a2,
"[a1] * -> [a2] *",
superclasses=self.a)
self.a_association.superclasses = [a2_association]
eq_(self.a_association.superclasses, [a2_association])
eq_(self.a_association.all_subclasses, set())
eq_(self.a_association.all_superclasses, {a2_association, self.a})
eq_(a2_association.superclasses, [self.a])
eq_(a2_association.subclasses, [self.a_association])
eq_(a2_association.all_subclasses, {self.a_association})
eq_(a2_association.has_subclass(self.a_association), True)
eq_(a2_association.has_subclass(self.a1), False)
eq_(a2_association.has_superclass(self.a_association), False)
eq_(a2_association.has_superclass(self.a), True)
eq_(self.a_association.is_classifier_of_type(self.a_association), True)
eq_(self.a_association.is_classifier_of_type(a2_association), True)
eq_(self.a_association.is_classifier_of_type(self.a), True)
eq_(self.a_association.is_classifier_of_type(self.a1), False)
# test linking still works after superclass changes
self.b_1.delete_links([self.a_links[0], self.a_links[1]])
eq_(self.b_1.get_linked(), [])
self.b_a_links = set_links(
{self.b_1: [self.a_links[1], self.a_links[0]]},
association=self.b_a_association)
eq_(self.b_1.get_linked(), [self.a_links[1], self.a_links[0]])
def test_delete_linked_association(self):
self.create_simple_link_object_test_setup()
self.a_association.delete()
eq_(self.a.subclasses, [self.a1, self.a2])
eq_(self.a2_1.get_linked(), [])
eq_(self.b_1.get_linked(), [])
def test_delete_linking_association(self):
self.create_simple_link_object_test_setup()
self.b_a_association.delete()
eq_(self.a2_1.get_linked(), [self.a1_1, self.a1_2])
eq_(self.b_1.get_linked(), [])
def test_link_object_classifier(self):
self.create_simple_link_object_test_setup()
eq_(self.a_links[0].classifier, self.a_association)
eq_(self.b_a_links[0].classifier, self.b_a_association)
try:
self.a_links[0].classifier = self.b_a_association
exception_expected_()
except CException as e:
eq_(
"Changes to the classifier (i.e., the association) of a link" +
" should not be performed with CObject methods", e.value)
def test_link_object_class_object_class(self):
self.create_simple_link_object_test_setup()
eq_(self.a_links[0].class_object_class, None)
eq_(self.b_a_links[0].class_object_class, None)
def test_link_object_instance_of(self):
self.create_simple_link_object_test_setup()
eq_(self.a_links[0].instance_of(self.a_association), True)
eq_(self.a_links[0].instance_of(self.b_a_association), False)
eq_(self.a_links[0].instance_of(self.a), True)
eq_(self.a_links[0].instance_of(self.a1), False)
try:
eq_(self.a_links[0].instance_of(self.mcl), False)
exception_expected_()
except CException as e:
eq_("'MCL' is not an association or a class", e.value)
eq_(self.b_a_links[0].instance_of(self.a_association), False)
eq_(self.b_a_links[0].instance_of(self.b_a_association), True)
eq_(self.b_a_links[0].instance_of(self.a), False)
def test_link_object_delete(self):
self.create_simple_link_object_test_setup()
self.a_links[0].delete()
self.b_a_links[0].delete()
eq_(self.b_1.get_linked(), [self.a_links[1]])
eq_(self.a2_1.get_linked(), [self.a1_2])
eq_(self.a_links[1].get_linked(), [self.b_1])
try:
self.a_links[0].get_value("a")
exception_expected_()
except CException as e:
eq_("can't get value 'a' on deleted link", e.value)
try:
self.a_links[0].delete_value("a")
exception_expected_()
except CException as e:
eq_("can't delete value 'a' on deleted link", e.value)
try:
self.a_links[0].set_value("a", 1)
exception_expected_()
except CException as e:
eq_("can't set value 'a' on deleted link", e.value)
try:
self.a_links[0].values = {"a": 1}
exception_expected_()
except CException as e:
eq_("can't set values on deleted link", e.value)
def test_object_link_classifier_bundable(self):
self.create_simple_link_object_test_setup()
bundle = CBundle("Bundle", elements=self.a.get_connected_elements())
eq_(set(bundle.elements), {self.a, self.a1, self.a2, self.b})
try:
bundle.elements = self.a.get_connected_elements(add_links=True)
exception_expected_()
except CException as e:
eq_(
"unknown keyword argument 'add_links', should be one of:" +
" ['add_associations', 'add_bundles', 'process_bundles', 'stop_elements_inclusive', "
+ "'stop_elements_exclusive']", e.value)
eq_(self.a_association.bundles, [])
bundle.elements = self.a.get_connected_elements(add_associations=True)
eq_(set(bundle.elements),
{self.a, self.a1, self.a2, self.b, self.a_association})
eq_(self.a_association.bundles, [bundle])
bundle2 = CBundle("Bundle2",
elements=self.a_association.get_connected_elements(
add_associations=True))
eq_(set(bundle2.elements),
{self.a, self.a1, self.a2, self.b, self.a_association})
eq_(set(self.a_association.bundles), {bundle, bundle2})
bundle2.delete()
eq_(set(self.a_association.bundles), {bundle})
self.a_association.delete()
eq_(set(bundle.elements), {self.a, self.a1, self.a2, self.b})
def test_object_link_bundable(self):
self.create_simple_link_object_test_setup()
bundle = CBundle("Bundle", elements=self.a1_1.get_connected_elements())
eq_(set(bundle.elements), {self.a1_1, self.a1_2, self.a2_1})
try:
bundle.elements = self.a1_1.get_connected_elements(
add_associations=True)
exception_expected_()
except CException as e:
eq_(
"unknown keyword argument 'add_associations', should be one of:"
+
" ['add_links', 'add_bundles', 'process_bundles', 'stop_elements_inclusive',"
+ " 'stop_elements_exclusive']", e.value)
bundle.elements = self.b_1.get_connected_elements()
eq_(set(bundle.elements), {self.b_1})
eq_(self.a_links[0].bundles, [])
bundle.elements = self.b_1.get_connected_elements(add_links=True)
eq_(set(bundle.elements), {self.b_1, self.a_links[0], self.a_links[1]})
eq_(self.a_links[0].bundles, [bundle])
bundle2 = CBundle(
"Bundle2",
elements=self.a_links[0].get_connected_elements(add_links=True))
eq_(set(bundle2.elements),
{self.b_1, self.a_links[0], self.a_links[1]})
eq_(set(self.a_links[0].bundles), {bundle, bundle2})
bundle2.delete()
eq_(set(self.a_links[0].bundles), {bundle})
self.a_links[0].delete()
eq_(set(bundle.elements), {self.b_1, self.a_links[1]})
def test_reference_to_link(self):
code = CClass(self.mcl, "Code")
source = CClass(self.mcl, "Source")
code_association = code.association(
source, "[contained_code] * -> [source] *")
code_a = CClass(self.mcl, "Code A", superclasses=code)
code_b = CClass(self.mcl, "Code B", superclasses=code)
a_b_association = code_a.association(code_b,
"a_b: [code_a] * -> [code_b] *",
superclasses=code)
source_1 = CObject(source, "source_1")
code_a1 = CObject(code_a, "code_a1")
code_b1 = CObject(code_b, "code_b1")
code_b2 = CObject(code_b, "code_b2")
code_b3 = CObject(code_b, "code_b3")
a_b_links = add_links({code_a1: [code_b1, code_b2]},
association=a_b_association)
code_links = add_links(
{
source_1:
[code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]]
},
role_name="contained_code")
eq_(len(code_links), 5)
# test getter methods on object
eq_(set(source_1.get_linked(role_name="contained_code")),
{code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]})
eq_(set(source_1.linked),
{code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]})
eq_(set(source_1.links), set(code_links))
eq_(set(source_1.get_links_for_association(code_association)),
set(code_links))
eq_(set(get_links([source_1])), set(code_links))
# test getter methods on link
eq_(a_b_links[0].get_linked(role_name="source"), [source_1])
eq_(a_b_links[0].linked, [source_1])
eq_(a_b_links[0].links, [code_links[3]])
eq_(a_b_links[0].get_links_for_association(code_association),
[code_links[3]])
eq_(set(get_links([a_b_links[0]])), {code_links[3]})
eq_(
set(get_links([code_a1, a_b_links[0], a_b_links[1]])), {
code_links[0], a_b_links[0], a_b_links[1], code_links[3],
code_links[4]
})
# test add/delete links
code_b3_link = code_a1.add_links(code_b3)[0]
source_1.add_links(code_b3_link)
eq_(set(code_a1.linked), {code_b1, code_b2, source_1, code_b3})
eq_(set(source_1.linked), {
code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1], code_b3_link
})
eq_(code_b3_link.linked, [source_1])
a_b_links[1].delete_links([source_1])
eq_(set(source_1.linked),
{code_a1, code_b2, code_b1, a_b_links[0], code_b3_link})
source_1.delete_links([code_a1, a_b_links[0]])
eq_(set(source_1.linked), {code_b2, code_b1, code_b3_link})
# test whether metaclass links fail on class
mcl_a = CMetaclass("M")
mcl_b = CMetaclass("Source")
mcl_association = mcl_a.association(mcl_b, "[a] * -> [b] *")
cl_a = CClass(mcl_a, "cla")
cl_b = CClass(mcl_a, "clb")
class_link = add_links({cl_a: [cl_b]}, association=mcl_association)[0]
try:
add_links({source_1: [code_a1, code_b2, code_b1, class_link]},
role_name="contained_code")
exception_expected_()
except CException as e:
eq_("link target is a class link, but source is an object",
e.value)
