def setup(self):
self.stereotypeBundle = CBundle("Elements")
self.s1 = CStereotype("S1", bundles=self.stereotypeBundle)
self.s2 = CStereotype("S2", bundles=self.stereotypeBundle)
self.s3 = CStereotype("S3", bundles=self.stereotypeBundle)
self.s4 = CStereotype("S4", bundles=self.stereotypeBundle)
self.s5 = CStereotype("S5", bundles=self.stereotypeBundle)
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 test_bundle_that_is_deleted(self):
b1 = CBundle("B1")
b1.delete()
try:
CStereotype("S1", bundles=b1)
exception_expected_()
except CException as e:
eq_(e.value, "cannot access named element that has been deleted")
def test_creation_of_unnamed_bundle_in_bundle(self):
b1 = CBundle()
b2 = CBundle()
b3 = CBundle("x")
mcl = CMetaclass()
self.b1.elements = [b1, b2, b3, mcl]
eq_(set(self.b1.get_elements(type=CBundle)), {b1, b2, b3})
eq_(self.b1.get_element(name=None, type=CBundle), b1)
eq_(set(self.b1.get_elements(name=None, type=CBundle)), {b1, b2})
eq_(set(self.b1.get_elements(name=None)), {b1, b2, mcl})
def test_class_link_bundable(self):
self.create_simple_link_object_test_setup()
bundle = CBundle("Bundle", elements=self.a1_1.class_object.get_connected_elements())
eq_(set(bundle.elements), {self.a1_1.class_object, self.a1_2.class_object, self.a2_1.class_object})
try:
bundle.elements = self.a1_1.class_object.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.class_object.get_connected_elements()
eq_(set(bundle.elements), {self.b_1.class_object})
eq_(self.a_links[0].bundles, [])
bundle.elements = self.b_1.class_object.get_connected_elements(add_links=True)
eq_(set(bundle.elements), {self.b_1.class_object, 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.class_object, 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.class_object, self.a_links[1]})
def test_bundle_defined_bundles(self):
eq_(set(self.b1.get_elements()), set())
b1 = CBundle("B1", bundles=self.b1)
eq_(set(self.b1.get_elements()), {b1})
b2 = CBundle("B2", bundles=[self.b1])
b3 = CBundle("B3", bundles=[self.b1, self.b2])
mcl = CMetaclass("MCL", bundles=self.b1)
eq_(set(self.b1.get_elements(type=CBundle)), {b1, b2, b3})
eq_(set(self.b1.elements), {b1, b2, b3, mcl})
eq_(set(self.b2.get_elements(type=CBundle)), {b3})
eq_(set(self.b2.elements), {b3})
def test_delete_bundle_from_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
ba = CBundle("ba", bundles=[b1, b2])
b1.delete()
eq_(set(b1.get_elements(type=CBundle)), set())
eq_(set(b2.get_elements(type=CBundle)), {ba})
eq_(set(ba.bundles), {b2})
def setup(self):
self.mcl = CMetaclass("MCL")
self.b1 = CBundle("B1")
self.b2 = CBundle("B2")
self.m1 = CMetaclass("M1")
self.m2 = CMetaclass("M2")
self.a = self.m1.association(self.m2,
name="A",
multiplicity="1",
role_name="m1",
source_multiplicity="*",
source_role_name="m2")
def test_get_bundle_elements_by_name(self):
eq_(set(self.b1.get_elements(name="B1")), set())
b1 = CBundle("B1", bundles=self.b1)
eq_(set(self.b1.get_elements(name="B1")), {b1})
m = CMetaclass("B1", bundles=self.b1)
eq_(set(self.b1.get_elements(name="B1")), {m, b1})
b2 = CBundle("B1", bundles=self.b1)
eq_(set(self.b1.get_elements(name="B1")), {m, b1, b2})
ok_(b1 != b2)
b3 = CBundle("B1", bundles=self.b1)
eq_(set(self.b1.get_elements(name="B1")), {m, b1, b2, b3})
eq_(self.b1.get_element(name="B1"), b1)
def test_bundle_delete_bundle(self):
b1 = CBundle("B1", bundles=self.b1)
b2 = CBundle("B2", bundles=self.b1)
b3 = CBundle("P3", bundles=self.b1)
self.b1.delete()
eq_(set(self.b1.elements), set())
eq_(b1.get_elements(type=CBundle), [])
eq_(b1.elements, [])
eq_(b2.get_elements(type=CBundle), [])
eq_(b3.get_elements(type=CBundle), [])
def test_delete_bundle_from_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
m1 = CMetaclass("m1", bundles=[b1, b2])
b1.delete()
eq_(set(b1.get_elements(type=CMetaclass)), set())
eq_(set(b2.get_elements(type=CMetaclass)), {m1})
eq_(set(m1.bundles), {b2})
def test_delete_bundle_from_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
c1 = CClass(self.mcl, "c1", bundles=[b1, b2])
b1.delete()
eq_(set(b1.get_elements(type=CClass)), set())
eq_(set(b2.get_elements(type=CClass)), {c1})
eq_(set(c1.bundles), {b2})
def test_delete_bundle_from_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
s1 = CStereotype("s1", bundles=[b1, b2])
b1.delete()
eq_(set(b1.get_elements(type=CStereotype)), set())
eq_(set(b2.get_elements(type=CStereotype)), {s1})
eq_(set(s1.bundles), {b2})
def test_delete_bundle_from_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
e1 = CEnum("e1", bundles=[b1, b2])
b1.delete()
eq_(set(b1.get_elements(type=CEnum)), set())
eq_(set(b2.get_elements(type=CEnum)), {e1})
eq_(set(e1.bundles), {b2})
def test_delete_enum_that_is_an_attribute_type(self):
b1 = CBundle("B1")
CBundle("B2")
e1 = CEnum("E1", bundles=b1)
e2 = CEnum("E2", bundles=b1)
e3 = CEnum("E3", values=["1", "2"], bundles=b1)
ea1 = CAttribute(type=e3, default="1")
ea2 = CAttribute(type=e3)
cl = CClass(self.mcl, attributes={"letters1": ea1, "letters2": ea2})
o = CObject(cl, "o")
e1.delete()
e3.delete()
try:
ea1.default = "3"
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.type = e1
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.default = "3"
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.type = e1
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.type = e2
exception_expected_()
except CException as e:
eq_("default value '1' incompatible with attribute's type 'E2'",
e.value)
try:
o.set_value("letters1", "1")
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
o.get_value("letters1")
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
def test_enum_defined_bundle_change(self):
e1 = CEnum("E1", bundles=self.b1)
e2 = CEnum("E2", bundles=self.b1)
e3 = CEnum("E3", bundles=self.b1)
mcl = CMetaclass("MCL", bundles=self.b1)
b = CBundle()
e2.bundles = b
e3.bundles = None
self.mcl.bundles = b
eq_(set(self.b1.elements), {mcl, e1})
eq_(set(self.b1.get_elements(type=CEnum)), {e1})
eq_(set(b.elements), {e2, self.mcl})
eq_(set(b.get_elements(type=CEnum)), {e2})
eq_(e1.bundles, [self.b1])
eq_(e2.bundles, [b])
eq_(e3.bundles, [])
def test_bundle_defined_bundle_change(self):
b1 = CBundle("B1", bundles=self.b1)
b2 = CBundle("B2", bundles=self.b1)
b3 = CBundle("P3", bundles=self.b1)
mcl = CMetaclass("MCL", bundles=self.b1)
b = CBundle()
b2.bundles = b
b3.bundles = None
self.mcl.bundles = b
eq_(set(self.b1.elements), {mcl, b1})
eq_(set(self.b1.get_elements(type=CBundle)), {b1})
eq_(set(b.elements), {b2, self.mcl})
eq_(set(b.get_elements(type=CBundle)), {b2})
eq_(b1.bundles, [self.b1])
eq_(b2.bundles, [b])
eq_(b3.bundles, [])
def test_class_defined_bundle_change(self):
cl1 = CClass(self.mcl, "Class1", bundles=self.b1)
cl2 = CClass(self.mcl, "Class2", bundles=self.b1)
cl3 = CClass(self.mcl, "Class3", bundles=self.b1)
mcl = CMetaclass("MCL", bundles=self.b1)
b = CBundle()
cl2.bundles = b
cl3.bundles = None
self.mcl.bundles = b
eq_(set(self.b1.elements), {mcl, cl1})
eq_(set(self.b1.get_elements(type=CClass)), {cl1})
eq_(set(b.elements), {cl2, self.mcl})
eq_(set(b.get_elements(type=CClass)), {cl2})
eq_(cl1.bundles, [self.b1])
eq_(cl2.bundles, [b])
eq_(cl3.bundles, [])
def test_wrongs_types_in_list_of_extended_element_types(self):
try:
CStereotype("S", extended=[self.a, self.m1])
exception_expected_()
except CException as e:
eq_("'M1' is not a association", e.value)
try:
CStereotype("S", extended=[self.a, CBundle("P")])
exception_expected_()
except CException as e:
eq_("'P' is not a association", e.value)
try:
CStereotype("S", extended=[CBundle("P"), self.a])
exception_expected_()
except CException as e:
eq_("unknown type of extend element: 'P'", e.value)
def test_bundle_name_fail(self):
try:
# noinspection PyTypeChecker
CBundle(self.mcl)
exception_expected_()
except CException as e:
ok_(e.value.startswith("is not a name string: '"))
ok_(e.value.endswith(" MCL'"))
def test_stereotype_defined_bundle_change(self):
s1 = CStereotype("s1", bundles=self.b1)
s2 = CStereotype("s2", bundles=self.b1)
s3 = CStereotype("s3", bundles=self.b1)
cl1 = CClass(self.mcl, "C1", bundles=self.b1)
cl2 = CClass(self.mcl, "C2", bundles=self.b1)
b = CBundle()
s2.bundles = b
s3.bundles = None
cl2.bundles = b
eq_(set(self.b1.elements), {cl1, s1})
eq_(set(self.b1.get_elements(type=CStereotype)), {s1})
eq_(set(b.elements), {s2, cl2})
eq_(set(b.get_elements(type=CStereotype)), {s2})
eq_(s1.bundles, [self.b1])
eq_(s2.bundles, [b])
eq_(s3.bundles, [])
def test_bundle_elements_that_are_deleted(self):
c = CClass(self.mcl, "C")
c.delete()
try:
CBundle("B1", elements=[c])
exception_expected_()
except CException as e:
eq_(e.value, "cannot access named element that has been deleted")
def test_metaclass_defined_bundle_change(self):
m1 = CMetaclass("M1", bundles=self.b1)
m2 = CMetaclass("M2", bundles=self.b1)
m3 = CMetaclass("M3", bundles=self.b1)
cl1 = CClass(m1, "C1", bundles=self.b1)
cl2 = CClass(m1, "C2", bundles=self.b1)
b = CBundle()
m2.bundles = b
m3.bundles = None
cl2.bundles = b
eq_(set(self.b1.elements), {cl1, m1})
eq_(set(self.b1.get_elements(type=CMetaclass)), {m1})
eq_(set(b.elements), {m2, cl2})
eq_(set(b.get_elements(type=CMetaclass)), {m2})
eq_(m1.bundles, [self.b1])
eq_(m2.bundles, [b])
eq_(m3.bundles, [])
def test_wrongs_types_in_list_of_extended_element_types(self):
try:
CStereotype(
"S",
extended=[self.mcl,
self.mcl.association(self.mcl, name="A")])
exception_expected_()
except CException as e:
eq_("'A' is not a metaclass", e.value)
try:
CStereotype("S", extended=[self.mcl, CBundle("P")])
exception_expected_()
except CException as e:
eq_("'P' is not a metaclass", e.value)
try:
CStereotype("S", extended=[CBundle("P"), self.mcl])
exception_expected_()
except CException as e:
eq_("unknown type of extend element: 'P'", e.value)
def test_bundle_defined_by_bundle_list(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
b3 = CBundle("P3")
eq_(set(self.b1.get_elements(type=CBundle)), set())
ba = CBundle("PA", elements=[b1, b2, b3])
eq_(set(ba.elements), {b1, b2, b3})
self.mcl.bundles = ba
eq_(set(ba.elements), {b1, b2, b3, self.mcl})
eq_(set(ba.get_elements(type=CBundle)), {b1, b2, b3})
bb = CBundle("PB")
bb.elements = [b2, b3]
eq_(set(bb.get_elements(type=CBundle)), {b2, b3})
eq_(set(b1.bundles), {ba})
eq_(set(b2.bundles), {ba, bb})
eq_(set(b3.bundles), {ba, bb})
eq_(set(ba.bundles), set())
eq_(set(bb.bundles), set())
eq_(set(b1.elements), set())
eq_(set(b2.elements), set())
eq_(set(b3.elements), set())
def test_delete_class_from_bundle(self):
b1 = CBundle("B1")
cl1 = CClass(self.mcl, "CL1", bundles=b1)
cl1.delete()
eq_(set(b1.get_elements(type=CClass)), set())
cl1 = CClass(self.mcl, "CL1", bundles=b1)
cl2 = CClass(self.mcl, "CL2", bundles=b1)
cl3 = CClass(self.mcl,
"CL3",
superclasses=cl2,
attributes={"i": 1},
bundles=b1)
cl3.set_value("i", 7)
CObject(cl3, bundles=b1)
cl1.delete()
eq_(set(b1.get_elements(type=CClass)), {cl2, cl3})
cl3.delete()
eq_(set(b1.get_elements(type=CClass)), {cl2})
eq_(cl3.superclasses, [])
eq_(cl2.subclasses, [])
eq_(cl3.attributes, [])
eq_(cl3.attribute_names, [])
eq_(cl3.metaclass, None)
eq_(cl3.objects, [])
eq_(cl3.name, None)
eq_(cl3.bundles, [])
eq_(b1.get_elements(type=CObject), [])
try:
cl3.get_value("i")
exception_expected_()
except CException as e:
eq_("can't get value 'i' on deleted class", e.value)
def test_delete_stereotype_from_bundle(self):
b1 = CBundle("B1")
s1 = CStereotype("s1", bundles=b1)
s1.delete()
eq_(set(b1.get_elements(type=CStereotype)), set())
s1 = CStereotype("s1", bundles=b1)
s2 = CStereotype("s1", bundles=b1)
s3 = CStereotype("s1",
superclasses=s2,
attributes={"i": 1},
bundles=b1,
extended=self.mcl)
s4 = CStereotype("s1",
superclasses=s2,
attributes={"i": 1},
bundles=b1,
extended=self.a)
s1.delete()
eq_(set(b1.get_elements(type=CStereotype)), {s2, s3, s4})
s3.delete()
s4.delete()
eq_(set(b1.get_elements(type=CStereotype)), {s2})
eq_(s3.superclasses, [])
eq_(s2.subclasses, [])
eq_(s3.attributes, [])
eq_(s3.attribute_names, [])
eq_(s3.extended, [])
eq_(s3.name, None)
eq_(s3.bundles, [])
eq_(s4.superclasses, [])
eq_(s4.attributes, [])
eq_(s4.attribute_names, [])
eq_(s4.extended, [])
eq_(s4.name, None)
eq_(s4.bundles, [])
def test_delete_class_that_is_an_attribute_type(self):
b1 = CBundle("B1")
mcl = CMetaclass("MCL")
cl1 = CClass(mcl, "CL1", bundles=b1)
cl2 = CClass(mcl, "CL2", bundles=b1)
cl3 = CClass(mcl, "CL3", bundles=b1)
o3 = CObject(cl3, "O3")
ea1 = CAttribute(type=cl3, default=o3)
m = CMetaclass("M", bundles=b1, attributes={"o": ea1})
c = CClass(m)
cl1.delete()
cl3.delete()
try:
# we just use list here, in order to not get a warning that ea1.default has no effect
list([ea1.default])
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
# we just use list here, in order to not get a warning that ea1.type has no effect
list([ea1.type])
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.default = "3"
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.type = cl1
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
ea1.type = cl2
exception_expected_()
except CException as e:
eq_("default value '' incompatible with attribute's type 'CL2'",
e.value)
try:
c.set_value("o", CObject(cl2))
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
c.get_value("o")
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
def test_delete_stereotype_having_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
s1 = CStereotype("s1", bundles=[b1, b2])
s2 = CStereotype("s2", bundles=[b2])
s1.delete()
eq_(set(b1.get_elements(type=CStereotype)), set())
eq_(set(b2.get_elements(type=CStereotype)), {s2})
eq_(set(s1.bundles), set())
eq_(set(s2.bundles), {b2})
def test_delete_class_having_two_bundles(self):
b1 = CBundle("B1")
b2 = CBundle("B2")
c1 = CClass(self.mcl, "c1", bundles=[b1, b2])
c2 = CClass(self.mcl, "c2", bundles=[b2])
c1.delete()
eq_(set(b1.get_elements(type=CClass)), set())
eq_(set(b2.get_elements(type=CClass)), {c2})
eq_(set(c1.bundles), set())
eq_(set(c2.bundles), {b2})
