def test_attribute_values_inheritance(self):
t1 = CClass(self.mcl, "T1")
t2 = CClass(self.mcl, "T2")
c = CClass(self.mcl, "C", superclasses=[t1, t2])
sc = CClass(self.mcl, "C", superclasses=c)
t1.attributes = {"i0": 0}
t2.attributes = {"i1": 1}
c.attributes = {"i2": 2}
sc.attributes = {"i3": 3}
o = CObject(sc, "o")
for name, value in {"i0": 0, "i1": 1, "i2": 2, "i3": 3}.items():
eq_(o.get_value(name), value)
eq_(o.get_value("i0", t1), 0)
eq_(o.get_value("i1", t2), 1)
eq_(o.get_value("i2", c), 2)
eq_(o.get_value("i3", sc), 3)
for name, value in {"i0": 10, "i1": 11, "i2": 12, "i3": 13}.items():
o.set_value(name, value)
for name, value in {"i0": 10, "i1": 11, "i2": 12, "i3": 13}.items():
eq_(o.get_value(name), value)
eq_(o.get_value("i0", t1), 10)
eq_(o.get_value("i1", t2), 11)
eq_(o.get_value("i2", c), 12)
eq_(o.get_value("i3", sc), 13)
def test_attribute_value_type_check_list(self):
self.cl.attributes = {"t": list}
o = CObject(self.cl, "o")
try:
o.set_value("t", True)
exception_expected_()
except CException as e:
eq_(f"value type for attribute 't' does not match attribute type", e.value)
def test_attribute_value_type_check_bool1(self):
self.cl.attributes = {"t": bool}
o = CObject(self.cl, "o")
try:
o.set_value("t", self.mcl)
exception_expected_()
except CException as e:
eq_(f"value for attribute 't' is not a known attribute type", e.value)
def test_attribute_value_type_check_enum(self):
enum_type = CEnum("EnumT", values=["A", "B", "C"])
self.cl.attributes = {"t": enum_type}
o = CObject(self.cl, "o")
try:
o.set_value("t", True)
exception_expected_()
except CException as e:
eq_(f"value type for attribute 't' does not match attribute type", e.value)
def test_attribute_value_type_check_object(self):
attribute_type = CClass(self.mcl, "AttrType")
self.cl.attributes = {"t": attribute_type}
o = CObject(self.cl, "o")
try:
o.set_value("t", True)
exception_expected_()
except CException as e:
eq_(f"value type for attribute 't' does not match attribute type", e.value)
def test_attribute_values_inheritance_after_delete_superclass(self):
t1 = CClass(self.mcl, "T1")
t2 = CClass(self.mcl, "T2")
c = CClass(self.mcl, "C", superclasses=[t1, t2])
sc = CClass(self.mcl, "C", superclasses=c)
t1.attributes = {"i0": 0}
t2.attributes = {"i1": 1}
c.attributes = {"i2": 2}
sc.attributes = {"i3": 3}
o = CObject(sc, "o")
t2.delete()
for name, value in {"i0": 0, "i2": 2, "i3": 3}.items():
eq_(o.get_value(name), value)
try:
o.get_value("i1")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for 'o'")
eq_(o.get_value("i0", t1), 0)
try:
o.get_value("i1", t2)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for ''")
eq_(o.get_value("i2", c), 2)
eq_(o.get_value("i3", sc), 3)
for name, value in {"i0": 10, "i2": 12, "i3": 13}.items():
o.set_value(name, value)
try:
o.set_value("i1", 11)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for 'o'")
for name, value in {"i0": 10, "i2": 12, "i3": 13}.items():
eq_(o.get_value(name), value)
try:
o.get_value("i1")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for 'o'")
eq_(o.get_value("i0", t1), 10)
try:
o.get_value("i1", t2)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'i1' unknown for ''")
eq_(o.get_value("i2", c), 12)
eq_(o.get_value("i3", sc), 13)
def test_object_attribute_of_superclass_type(self):
attribute_super_type = CClass(self.mcl, "AttrSuperType")
attribute_type = CClass(self.mcl, "AttrType", superclasses=attribute_super_type)
attribute_value = CObject(attribute_type, "attribute_value")
o = CObject(self.cl, "o1")
self.cl.attributes = {
"attrTypeObj1": attribute_super_type, "attrTypeObj2": attribute_value
}
o.set_value("attrTypeObj1", attribute_value)
o.set_value("attrTypeObj2", attribute_value)
eq_(o.get_value("attrTypeObj1"), attribute_value)
eq_(o.get_value("attrTypeObj2"), attribute_value)
def test_delete_class_that_is_an_attribute_type(self):
b1 = CBundle("B1")
cl1 = CClass(self.mcl, "CL1", bundles=b1)
cl2 = CClass(self.mcl, "CL2", bundles=b1)
cl3 = CClass(self.mcl, "CL3", bundles=b1)
o3 = CObject(cl3, "O3")
ea1 = CAttribute(type=cl3, default=o3)
c = CClass(self.mcl, "C", bundles=b1, attributes={"o": ea1})
o = CObject(c)
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:
o.set_value("o", CObject(cl2))
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
try:
o.get_value("o")
exception_expected_()
except CException as e:
eq_("cannot access named element that has been deleted", e.value)
def test_attribute_of_value_unknown(self):
o = CObject(self.cl, "o")
try:
o.get_value("x")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'x' unknown for 'o'")
self.cl.attributes = {"isBoolean": True, "intVal": 1}
try:
o.set_value("x", 1)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'x' unknown for 'o'")
def test_object_type_attribute_values(self):
attribute_type = CClass(self.mcl, "AttrType")
attribute_value = CObject(attribute_type, "attribute_value")
self.cl.attributes = {"attrTypeObj": attribute_value}
object_attribute = self.cl.get_attribute("attrTypeObj")
eq_(object_attribute.type, attribute_type)
o = CObject(self.cl, "o")
eq_(o.get_value("attrTypeObj"), attribute_value)
non_attribute_value = CObject(self.cl, "non_attribute_value")
try:
o.set_value("attrTypeObj", non_attribute_value)
exception_expected_()
except CException as e:
eq_(e.value, "type of 'non_attribute_value' is not matching type of attribute 'attrTypeObj'")
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_class_type_attribute_values(self):
attribute_type = CMetaclass("AttrType")
attribute_value = CClass(attribute_type, "attribute_value")
self.cl.attributes = {"attrTypeCl": attribute_type}
class_attribute = self.cl.get_attribute("attrTypeCl")
class_attribute.default = attribute_value
eq_(class_attribute.type, attribute_type)
o = CObject(self.cl, "o")
eq_(o.get_value("attrTypeCl"), attribute_value)
non_attribute_value = CClass(CMetaclass("MX"), "non_attribute_value")
try:
o.set_value("attrTypeCl", non_attribute_value)
exception_expected_()
except CException as e:
eq_(e.value, "type of 'non_attribute_value' is not matching type of attribute 'attrTypeCl'")
def test_attributes_overwrite_no_defaults(self):
cl = CClass(self.mcl, "C", attributes={
"isBoolean": bool,
"intVal": int})
o = CObject(cl, "o")
eq_(o.get_value("isBoolean"), None)
o.set_value("isBoolean", False)
cl.attributes = {
"isBoolean": bool,
"intVal": int,
"floatVal": float}
eq_(o.get_value("isBoolean"), False)
eq_(o.get_value("floatVal"), None)
eq_(o.get_value("intVal"), None)
o.set_value("floatVal", 1.2)
eq_(o.get_value("floatVal"), 1.2)
def test_values_multiple_inheritance(self):
t1 = CClass(self.mcl, "T1")
t2 = CClass(self.mcl, "T2")
st_a = CClass(self.mcl, "STA", superclasses=[t1, t2])
sub_a = CClass(self.mcl, "SubA", superclasses=[st_a])
st_b = CClass(self.mcl, "STB", superclasses=[t1, t2])
sub_b = CClass(self.mcl, "SubB", superclasses=[st_b])
st_c = CClass(self.mcl, "STC")
sub_c = CClass(self.mcl, "SubC", superclasses=[st_c])
cl = CClass(self.mcl, "M", superclasses=[sub_a, sub_b, sub_c])
o = CObject(cl)
t1.attributes = {"i0": 0}
t2.attributes = {"i1": 1}
st_a.attributes = {"i2": 2}
sub_a.attributes = {"i3": 3}
st_b.attributes = {"i4": 4}
sub_b.attributes = {"i5": 5}
st_c.attributes = {"i6": 6}
sub_c.attributes = {"i7": 7}
eq_(o.get_value("i0"), 0)
eq_(o.get_value("i1"), 1)
eq_(o.get_value("i2"), 2)
eq_(o.get_value("i3"), 3)
eq_(o.get_value("i4"), 4)
eq_(o.get_value("i5"), 5)
eq_(o.get_value("i6"), 6)
eq_(o.get_value("i7"), 7)
eq_(o.get_value("i0", t1), 0)
eq_(o.get_value("i1", t2), 1)
eq_(o.get_value("i2", st_a), 2)
eq_(o.get_value("i3", sub_a), 3)
eq_(o.get_value("i4", st_b), 4)
eq_(o.get_value("i5", sub_b), 5)
eq_(o.get_value("i6", st_c), 6)
eq_(o.get_value("i7", sub_c), 7)
o.set_value("i0", 10)
o.set_value("i1", 11)
o.set_value("i2", 12)
o.set_value("i3", 13)
o.set_value("i4", 14)
o.set_value("i5", 15)
o.set_value("i6", 16)
o.set_value("i7", 17)
eq_(o.get_value("i0"), 10)
eq_(o.get_value("i1"), 11)
eq_(o.get_value("i2"), 12)
eq_(o.get_value("i3"), 13)
eq_(o.get_value("i4"), 14)
eq_(o.get_value("i5"), 15)
eq_(o.get_value("i6"), 16)
eq_(o.get_value("i7"), 17)
def test_attribute_deleted_no_default(self):
cl = CClass(self.mcl, "C", attributes={
"isBoolean": bool,
"intVal": int})
cl.attributes = {"isBoolean": bool}
o = CObject(cl, "o")
eq_(o.get_value("isBoolean"), None)
try:
o.get_value("intVal")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'intVal' unknown for 'o'")
try:
o.set_value("intVal", 1)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'intVal' unknown for 'o'")
def test_enum_type_attribute_values(self):
enum_type = CEnum("EnumT", values=["A", "B", "C"])
cl = CClass(self.mcl, "C", attributes={
"e1": enum_type,
"e2": enum_type})
e2 = cl.get_attribute("e2")
e2.default = "A"
o = CObject(cl, "o")
eq_(o.get_value("e1"), None)
eq_(o.get_value("e2"), "A")
o.set_value("e1", "B")
o.set_value("e2", "C")
eq_(o.get_value("e1"), "B")
eq_(o.get_value("e2"), "C")
try:
o.set_value("e1", "X")
exception_expected_()
except CException as e:
eq_(e.value, "value 'X' is not element of enumeration")
def test_attribute_deleted(self):
cl = CClass(self.mcl, "C", attributes={
"isBoolean": True,
"intVal": 15})
o = CObject(cl, "o")
eq_(o.get_value("intVal"), 15)
cl.attributes = {
"isBoolean": False}
eq_(o.get_value("isBoolean"), True)
try:
o.get_value("intVal")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'intVal' unknown for 'o'")
try:
o.set_value("intVal", 1)
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'intVal' unknown for 'o'")
def test_attribute_values_exceptional_cases(self):
cl = CClass(self.mcl, "C", attributes={"b": True})
o1 = CObject(cl, "o")
o1.delete()
try:
o1.get_value("b")
exception_expected_()
except CException as e:
eq_(e.value, "can't get value 'b' on deleted object")
try:
o1.set_value("b", 1)
exception_expected_()
except CException as e:
eq_(e.value, "can't set value 'b' on deleted object")
try:
o1.delete_value("b")
exception_expected_()
except CException as e:
eq_(e.value, "can't delete value 'b' on deleted object")
try:
o1.values = {"b": 1}
exception_expected_()
except CException as e:
eq_(e.value, "can't set values on deleted object")
try:
# we just use list here, in order to not get a warning that o1.values has no effect
list(o1.values)
exception_expected_()
except CException as e:
eq_(e.value, "can't get values on deleted object")
o = CObject(cl, "o")
try:
o.delete_value("x")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'x' unknown for 'o'")
def test_attributes_overwrite(self):
cl = CClass(self.mcl, "C", attributes={
"isBoolean": True,
"intVal": 15})
o = CObject(cl, "o")
eq_(o.get_value("intVal"), 15)
try:
o.get_value("floatVal")
exception_expected_()
except CException as e:
eq_(e.value, "attribute 'floatVal' unknown for 'o'")
o.set_value("intVal", 18)
cl.attributes = {
"isBoolean": False,
"intVal": 19,
"floatVal": 25.1}
eq_(o.get_value("isBoolean"), True)
eq_(o.get_value("floatVal"), 25.1)
eq_(o.get_value("intVal"), 18)
o.set_value("floatVal", 1.2)
eq_(o.get_value("floatVal"), 1.2)
def test_delete_object(self):
o = CObject(self.cl, "o")
o.delete()
eq_(set(self.cl.objects), set())
o1 = CObject(self.cl, "o1")
o2 = CObject(self.cl, "o2")
o3 = CObject(self.cl, "o3")
o3.set_value("i", 7)
o1.delete()
eq_(set(self.cl.objects), {o2, o3})
o3.delete()
eq_(set(self.cl.objects), {o2})
eq_(o3.classifier, None)
eq_(set(self.cl.objects), {o2})
eq_(o3.name, None)
eq_(o3.bundles, [])
try:
o3.get_value("i")
exception_expected_()
except CException as e:
eq_("can't get value 'i' on deleted object", e.value)
def test_values_setter_with_superclass(self):
scl = CClass(self.mcl, "SCL", attributes={
"intVal": 20, "intVal2": 30})
cl = CClass(self.mcl, "C", superclasses=scl, attributes={
"isBoolean": True,
"intVal": 1})
o = CObject(cl, "o", values={
"isBoolean": False})
eq_(o.values, {"isBoolean": False, "intVal": 1, "intVal2": 30})
o.set_value("intVal", 12, scl)
o.set_value("intVal", 15, cl)
o.set_value("intVal2", 16, scl)
eq_(o.values, {"isBoolean": False, "intVal": 15, "intVal2": 16})
eq_(o.get_value("intVal", scl), 12)
eq_(o.get_value("intVal", cl), 15)
def test_integers_as_floats(self):
cl = CClass(self.mcl, "C", attributes={
"floatVal": float})
o = CObject(cl, "o")
o.set_value("floatVal", 15)
eq_(o.get_value("floatVal"), 15)
def new_customer(name=None, **kwargs):
a_customer = CObject(customer, name, **kwargs)
a_customer.set_value("id", get_customer_id())
return a_customer
def new_product(name=None, **kwargs):
a_product = CObject(product, name, **kwargs)
a_product.set_value("id", get_product_id())
return a_product
# get rid of the objects, we don't need from the imported shopping model
cart1.delete()
order1.delete()
for item_object in item.objects:
item_object.delete()
# define a new cart and order, as they would be created in the shopping session
cart1 = CObject(cart)
cart1_items = add_items_to_cart(cart1, [[premium_pen, 3]])
set_links({cart1: thomas_customer}, association=customer_cart_relation)
order1 = place_order(cart1)
# create and link the objects which have attributes or links
search_obj = CObject(search_item)
search_obj.set_value("search string", "pens")
view_shopping_cart_obj = CObject(view_shopping_cart)
view_shopping_cart_obj.add_links(cart1, role_name="cart")
add_to_shopping_cart_obj = CObject(add_to_shopping_cart)
add_to_shopping_cart_obj.add_links(cart1_items, role_name="item")
checkout_obj = CObject(checkout)
checkout_obj.add_links(order1, role_name="order")
view_item_obj = CObject(view_item)
view_item_obj.add_links(premium_pen, role_name="product")
# pass the full trace to create_trace to filter out the meaningful objects in the trace and link them
a_trace = create_trace([
CObject(initial_node_shopping_cart),
CObject(decision_node_search_browse),
CObject(merge_node_search), search_obj,
CObject(decision_node_found),
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 test_attribute_values_same_name_inheritance(self):
t1 = CClass(self.mcl, "T1")
t2 = CClass(self.mcl, "T2")
c = CClass(self.mcl, "C", superclasses=[t1, t2])
sc = CClass(self.mcl, "C", superclasses=c)
t1.attributes = {"i": 0}
t2.attributes = {"i": 1}
c.attributes = {"i": 2}
sc.attributes = {"i": 3}
o1 = CObject(sc)
o2 = CObject(c)
o3 = CObject(t1)
eq_(o1.get_value("i"), 3)
eq_(o2.get_value("i"), 2)
eq_(o3.get_value("i"), 0)
eq_(o1.get_value("i", sc), 3)
eq_(o1.get_value("i", c), 2)
eq_(o1.get_value("i", t2), 1)
eq_(o1.get_value("i", t1), 0)
eq_(o2.get_value("i", c), 2)
eq_(o2.get_value("i", t2), 1)
eq_(o2.get_value("i", t1), 0)
eq_(o3.get_value("i", t1), 0)
o1.set_value("i", 10)
o2.set_value("i", 11)
o3.set_value("i", 12)
eq_(o1.get_value("i"), 10)
eq_(o2.get_value("i"), 11)
eq_(o3.get_value("i"), 12)
eq_(o1.get_value("i", sc), 10)
eq_(o1.get_value("i", c), 2)
eq_(o1.get_value("i", t2), 1)
eq_(o1.get_value("i", t1), 0)
eq_(o2.get_value("i", c), 11)
eq_(o2.get_value("i", t2), 1)
eq_(o2.get_value("i", t1), 0)
eq_(o3.get_value("i", t1), 12)
o1.set_value("i", 130, sc)
o1.set_value("i", 100, t1)
o1.set_value("i", 110, t2)
o1.set_value("i", 120, c)
eq_(o1.get_value("i"), 130)
eq_(o1.get_value("i", sc), 130)
eq_(o1.get_value("i", c), 120)
eq_(o1.get_value("i", t2), 110)
eq_(o1.get_value("i", t1), 100)
def test_delete_enum_from_bundle(self):
b1 = CBundle("B1")
e1 = CEnum("E1", bundles=b1)
e1.delete()
eq_(set(b1.get_elements(type=CEnum)), set())
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()
eq_(set(b1.get_elements(type=CEnum)), {e2, e3})
e3.delete()
eq_(set(b1.get_elements(type=CEnum)), {e2})
eq_(e3.name, None)
eq_(e3.bundles, [])
eq_(e3.values, [])
eq_(set(cl.attributes), {ea1, ea2})
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 = 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_attribute_defined_after_instance(self):
cl = CClass(self.mcl, "C")
o = CObject(cl, "o")
cl.attributes = {"floatVal": float}
o.set_value("floatVal", 15)
eq_(o.get_value("floatVal"), 15)
def test_delete_attribute_values_with_superclass(self):
scl = CClass(self.mcl, "SCL", attributes={
"intVal": 20, "intVal2": 30})
cl = CClass(self.mcl, "C", superclasses=scl, attributes={
"isBoolean": True,
"intVal": 1})
o = CObject(cl, "o", values={
"isBoolean": False})
o.delete_value("isBoolean")
o.delete_value("intVal2")
eq_(o.values, {"intVal": 1})
o.set_value("intVal", 2, scl)
o.set_value("intVal", 3, cl)
eq_(o.values, {"intVal": 3})
o.delete_value("intVal")
eq_(o.values, {"intVal": 2})
o.set_value("intVal", 2, scl)
o.set_value("intVal", 3, cl)
o.delete_value("intVal", cl)
eq_(o.values, {"intVal": 2})
o.set_value("intVal", 2, scl)
o.set_value("intVal", 3, cl)
o.delete_value("intVal", scl)
eq_(o.values, {"intVal": 3})
