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_class(self): cl1 = CClass(self.mcl, "CL1") cl1.delete() eq_(set(self.mcl.classes), set()) cl1 = CClass(self.mcl, "CL1") cl2 = CClass(self.mcl, "CL2") cl3 = CClass(self.mcl, "CL3", superclasses=cl2, attributes={"i": 1}) cl3.set_value("i", 7) CObject(cl3) cl1.delete() eq_(set(self.mcl.classes), {cl2, cl3}) cl3.delete() eq_(set(self.mcl.classes), {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, []) try: cl3.get_value("i") exception_expected_() except CException as e: eq_("can't get value 'i' on deleted class", e.value)
def test_values_setter_overwrite(self): mcl = CMetaclass("M", attributes={"isBoolean": True, "intVal": 1}) cl = CClass(mcl, "C", values={"isBoolean": False, "intVal": 2}) cl.values = {"isBoolean": True, "intVal": 20} eq_(cl.get_value("isBoolean"), True) eq_(cl.get_value("intVal"), 20) eq_(cl.values, {'isBoolean': True, 'intVal': 20}) cl.values = {} # values should not delete existing values eq_(cl.values, {"isBoolean": True, "intVal": 20})
def test_attributes_overwrite_no_defaults(self): mcl = CMetaclass(attributes={"isBoolean": bool, "intVal": int}) cl = CClass(mcl, "C") eq_(cl.get_value("isBoolean"), None) cl.set_value("isBoolean", False) mcl.attributes = {"isBoolean": bool, "intVal": int, "floatVal": float} eq_(cl.get_value("isBoolean"), False) eq_(cl.get_value("floatVal"), None) eq_(cl.get_value("intVal"), None) cl.set_value("floatVal", 1.2) eq_(cl.get_value("floatVal"), 1.2)
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_attribute_of_value_unknown(self): cl = CClass(self.mcl, "C") try: cl.get_value("x") exception_expected_() except CException as e: eq_(e.value, "attribute 'x' unknown for 'C'") self.mcl.attributes = {"isBoolean": True, "intVal": 1} try: cl.set_value("x", 1) exception_expected_() except CException as e: eq_(e.value, "attribute 'x' unknown for 'C'")
def test_attribute_values_inheritance(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") for name, value in {"i0": 0, "i1": 1, "i2": 2, "i3": 3}.items(): eq_(cl.get_value(name), value) eq_(cl.get_value("i0", t1), 0) eq_(cl.get_value("i1", t2), 1) eq_(cl.get_value("i2", c), 2) eq_(cl.get_value("i3", sc), 3) for name, value in {"i0": 10, "i1": 11, "i2": 12, "i3": 13}.items(): cl.set_value(name, value) for name, value in {"i0": 10, "i1": 11, "i2": 12, "i3": 13}.items(): eq_(cl.get_value(name), value) eq_(cl.get_value("i0", t1), 10) eq_(cl.get_value("i1", t2), 11) eq_(cl.get_value("i2", c), 12) eq_(cl.get_value("i3", sc), 13)
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_attribute_deleted_no_default(self): mcl = CMetaclass(attributes={"isBoolean": bool, "intVal": int}) mcl.attributes = {"isBoolean": bool} cl = CClass(mcl, "C") eq_(cl.get_value("isBoolean"), None) try: cl.get_value("intVal") exception_expected_() except CException as e: eq_(e.value, "attribute 'intVal' unknown for 'C'") try: cl.set_value("intVal", 1) exception_expected_() except CException as e: eq_(e.value, "attribute 'intVal' unknown for 'C'")
def test_attribute_deleted(self): mcl = CMetaclass(attributes={"isBoolean": True, "intVal": 15}) cl = CClass(mcl, "C") eq_(cl.get_value("intVal"), 15) mcl.attributes = {"isBoolean": False} eq_(cl.get_value("isBoolean"), True) try: cl.get_value("intVal") exception_expected_() except CException as e: eq_(e.value, "attribute 'intVal' unknown for 'C'") try: cl.set_value("intVal", 1) exception_expected_() except CException as e: eq_(e.value, "attribute 'intVal' unknown for 'C'")
def test_default_init_after_instance_creation(self): enum_type = CEnum("EnumT", values=["A", "B", "C"]) mcl = CMetaclass(attributes={"e1": enum_type, "e2": enum_type}) cl = CClass(mcl, "C") e2 = mcl.get_attribute("e2") e2.default = "A" eq_(cl.get_value("e1"), None) eq_(cl.get_value("e2"), "A")
def test_enum_type_attribute_values(self): enum_type = CEnum("EnumT", values=["A", "B", "C"]) mcl = CMetaclass(attributes={"e1": enum_type, "e2": enum_type}) e2 = mcl.get_attribute("e2") e2.default = "A" cl = CClass(mcl, "C") eq_(cl.get_value("e1"), None) eq_(cl.get_value("e2"), "A") cl.set_value("e1", "B") cl.set_value("e2", "C") eq_(cl.get_value("e1"), "B") eq_(cl.get_value("e2"), "C") try: cl.set_value("e1", "X") exception_expected_() except CException as e: eq_(e.value, "value 'X' is not element of enumeration")
def test_remove_class_from_bundle(self): b1 = CBundle("B1") b2 = CBundle("B2") cl1 = CClass(self.mcl, "CL1", bundles=b1) try: # noinspection PyTypeChecker b1.remove(None) exception_expected_() except CException as e: eq_("'None' is not an element of the bundle", e.value) try: b1.remove(CEnum("A")) exception_expected_() except CException as e: eq_("'A' is not an element of the bundle", e.value) try: b2.remove(cl1) exception_expected_() except CException as e: eq_("'CL1' is not an element of the bundle", e.value) b1.remove(cl1) 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) o = CObject(cl3, bundles=b1) b1.remove(cl1) try: b1.remove(CClass(CMetaclass("MCL", bundles=b2), "CL2", bundles=b2)) exception_expected_() except CException as e: eq_("'CL2' is not an element of the bundle", e.value) try: b1.remove(cl1) exception_expected_() except CException as e: eq_("'CL1' is not an element of the bundle", e.value) eq_(set(b1.get_elements(type=CClass)), {cl2, cl3}) b1.remove(cl3) eq_(set(b1.get_elements(type=CClass)), {cl2}) eq_(cl3.superclasses, [cl2]) eq_(cl2.subclasses, [cl3]) eq_(cl3.attribute_names, ["i"]) eq_(cl3.metaclass, self.mcl) eq_(cl3.objects, [o]) eq_(cl3.name, "CL3") eq_(cl3.bundles, []) eq_(b1.get_elements(type=CObject), [o]) eq_(cl3.get_value("i"), 7)
def test_add_object_attribute_get_set_value(self): attr_type = CClass(self.mcl, "AttrType") attr_value = CObject(attr_type, "attribute_value") cl = CClass(self.mcl) self.mcl.attributes = { "attrTypeObj1": attr_type, "attrTypeObj2": attr_value } eq_(cl.get_value("attrTypeObj1"), None) eq_(cl.get_value("attrTypeObj2"), attr_value)
def test_attribute_values_exceptional_cases(self): mcl = CMetaclass("M", attributes={"b": True}) cl1 = CClass(mcl, "C") cl1.delete() try: cl1.get_value("b") exception_expected_() except CException as e: eq_(e.value, "can't get value 'b' on deleted class") try: cl1.set_value("b", 1) exception_expected_() except CException as e: eq_(e.value, "can't set value 'b' on deleted class") try: cl1.delete_value("b") exception_expected_() except CException as e: eq_(e.value, "can't delete value 'b' on deleted class") try: cl1.values = {"b": 1} exception_expected_() except CException as e: eq_(e.value, "can't set values on deleted class") try: # we just use list here, in order to not get a warning that cl1.values has no effect list(cl1.values) exception_expected_() except CException as e: eq_(e.value, "can't get values on deleted class") cl = CClass(mcl, "C") try: cl.delete_value("x") exception_expected_() except CException as e: eq_(e.value, "attribute 'x' unknown for 'C'")
def test_values_setter_with_superclass(self): mcl_super = CMetaclass("S_MCL", attributes={ "intVal": 20, "intVal2": 30 }) mcl = CMetaclass("M", superclasses=mcl_super, attributes={ "isBoolean": True, "intVal": 1 }) cl = CClass(mcl, "C", values={"isBoolean": False}) eq_(cl.values, {"isBoolean": False, "intVal": 1, "intVal2": 30}) cl.set_value("intVal", 12, mcl_super) cl.set_value("intVal", 15, mcl) cl.set_value("intVal2", 16, mcl_super) eq_(cl.values, {"isBoolean": False, "intVal": 15, "intVal2": 16}) eq_(cl.get_value("intVal", mcl_super), 12) eq_(cl.get_value("intVal", mcl), 15)
def test_object_attribute_of_superclass_type(self): attr_super_type = CClass(self.mcl, "AttrSuperType") attr_type = CClass(self.mcl, "AttrType", superclasses=attr_super_type) attr_value = CObject(attr_type, "attribute_value") cl = CClass(self.mcl) self.mcl.attributes = { "attrTypeObj1": attr_super_type, "attrTypeObj2": attr_value } cl.set_value("attrTypeObj1", attr_value) cl.set_value("attrTypeObj2", attr_value) eq_(cl.get_value("attrTypeObj1"), attr_value) eq_(cl.get_value("attrTypeObj2"), attr_value)
def test_values_on_attributes_with_no_default_values(self): attr_type = CClass(self.mcl, "AttrType") enum_type = CEnum("EnumT", values=["A", "B", "C"]) mcl = CMetaclass("M", attributes={ "b": bool, "i": int, "f": float, "s": str, "l": list, "C": attr_type, "e": enum_type }) cl = CClass(mcl, "C") for n in ["b", "i", "f", "s", "l", "C", "e"]: eq_(cl.get_value(n), None)
def test_attributes_overwrite(self): mcl = CMetaclass(attributes={"isBoolean": True, "intVal": 15}) cl = CClass(mcl, "C") eq_(cl.get_value("intVal"), 15) try: cl.get_value("floatVal") exception_expected_() except CException as e: eq_(e.value, "attribute 'floatVal' unknown for 'C'") cl.set_value("intVal", 18) mcl.attributes = {"isBoolean": False, "intVal": 19, "floatVal": 25.1} eq_(cl.get_value("isBoolean"), True) eq_(cl.get_value("floatVal"), 25.1) eq_(cl.get_value("intVal"), 18) cl.set_value("floatVal", 1.2) eq_(cl.get_value("floatVal"), 1.2)
def test_object_type_attribute_values(self): attr_type = CClass(self.mcl, "AttrType") attr_value = CObject(attr_type, "attribute_value") self.mcl.attributes = {"attrTypeObj": attr_value} obj_attr = self.mcl.get_attribute("attrTypeObj") eq_(obj_attr.type, attr_type) cl = CClass(self.mcl, "C") eq_(cl.get_value("attrTypeObj"), attr_value) non_attr_value = CObject(CClass(self.mcl), "non_attribute_value") try: cl.set_value("attrTypeObj", non_attr_value) exception_expected_() except CException as e: eq_( e.value, "type of 'non_attribute_value' is not matching type of attribute 'attrTypeObj'" )
def test_class_type_attribute_values(self): attr_type = CMetaclass("AttrType") attr_value = CClass(attr_type, "attribute_value") self.mcl.attributes = {"attrTypeCl": attr_type} cl_attr = self.mcl.get_attribute("attrTypeCl") cl_attr.default = attr_value eq_(cl_attr.type, attr_type) cl = CClass(self.mcl, "C") eq_(cl.get_value("attrTypeCl"), attr_value) non_attr_value = CClass(CMetaclass("MX"), "non_attribute_value") try: cl.set_value("attrTypeCl", non_attr_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_deleted_on_subclass_no_defaults(self): mcl = CMetaclass("M", attributes={"isBoolean": bool, "intVal": int}) mcl2 = CMetaclass("M2", attributes={"isBoolean": bool}, superclasses=mcl) cl = CClass(mcl2, "C") eq_(cl.get_value("isBoolean"), None) eq_(cl.get_value("isBoolean", mcl), None) eq_(cl.get_value("isBoolean", mcl2), None) mcl2.attributes = {} eq_(cl.get_value("isBoolean"), None) eq_(cl.get_value("intVal"), None) eq_(cl.get_value("isBoolean", mcl), None) try: cl.get_value("isBoolean", mcl2) exception_expected_() except CException as e: eq_(e.value, "attribute 'isBoolean' unknown for 'M2'")
def test_default_values_from_stereotype__stereotype_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) s1.delete() c2 = CClass(mcl2, "C2", stereotype_instances=s2) eq_(c1.get_value("aStr1"), "a") eq_(c1.get_value("aList1"), ["a"]) eq_(c1.get_value("aStr2"), "def2") eq_(c1.get_value("aList2"), []) eq_(c2.get_value("aStr1"), None) eq_(c2.get_value("aList1"), ["a"]) eq_(c2.get_value("aStr2"), "def2") eq_(c2.get_value("aList2"), ["d1", "d2"])
def test_values_defined_in_constructor(self): obj_val_type = CClass(CMetaclass()) obj_val = CObject(obj_val_type, "object_value") mcl = CMetaclass("M", attributes={ "isBoolean": True, "intVal": 1, "floatVal": 1.1, "string": "abc", "list": ["a", "b"], "obj": obj_val_type }) cl = CClass(mcl, "C", values={ "isBoolean": False, "intVal": 2, "floatVal": 2.1, "string": "y", "list": [], "obj": obj_val }) eq_(cl.get_value("isBoolean"), False) eq_(cl.get_value("intVal"), 2) eq_(cl.get_value("floatVal"), 2.1) eq_(cl.get_value("string"), "y") eq_(cl.get_value("list"), []) eq_(cl.get_value("obj"), obj_val) eq_( cl.values, { "isBoolean": False, "intVal": 2, "floatVal": 2.1, "string": "y", "list": [], "obj": obj_val })
def test_attribute_values_same_name_inheritance(self): t1 = CMetaclass("T1") t2 = CMetaclass("T2") c = CMetaclass("C", superclasses=[t1, t2]) sc = CMetaclass("C", superclasses=c) t1.attributes = {"i": 0} t2.attributes = {"i": 1} c.attributes = {"i": 2} sc.attributes = {"i": 3} cl1 = CClass(sc) cl2 = CClass(c) cl3 = CClass(t1) eq_(cl1.get_value("i"), 3) eq_(cl2.get_value("i"), 2) eq_(cl3.get_value("i"), 0) eq_(cl1.get_value("i", sc), 3) eq_(cl1.get_value("i", c), 2) eq_(cl1.get_value("i", t2), 1) eq_(cl1.get_value("i", t1), 0) eq_(cl2.get_value("i", c), 2) eq_(cl2.get_value("i", t2), 1) eq_(cl2.get_value("i", t1), 0) eq_(cl3.get_value("i", t1), 0) cl1.set_value("i", 10) cl2.set_value("i", 11) cl3.set_value("i", 12) eq_(cl1.get_value("i"), 10) eq_(cl2.get_value("i"), 11) eq_(cl3.get_value("i"), 12) eq_(cl1.get_value("i", sc), 10) eq_(cl1.get_value("i", c), 2) eq_(cl1.get_value("i", t2), 1) eq_(cl1.get_value("i", t1), 0) eq_(cl2.get_value("i", c), 11) eq_(cl2.get_value("i", t2), 1) eq_(cl2.get_value("i", t1), 0) eq_(cl3.get_value("i", t1), 12) cl1.set_value("i", 130, sc) cl1.set_value("i", 100, t1) cl1.set_value("i", 110, t2) cl1.set_value("i", 120, c) eq_(cl1.get_value("i"), 130) eq_(cl1.get_value("i", sc), 130) eq_(cl1.get_value("i", c), 120) eq_(cl1.get_value("i", t2), 110) eq_(cl1.get_value("i", t1), 100)
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_default_values_from_stereotype_on_class(self): mcl = CMetaclass("MCL", attributes={ "aStr1": str, "aList1": list, "aStr2": "def", "aList2": ["d1", "d2"], "b": bool }) s1 = CStereotype("S1", extended=mcl, default_values={ "aStr1": "a", "aList1": ["a"], "aStr2": "def2", "aList2": [] }) c1 = CClass(mcl, "C1", stereotype_instances=s1) eq_(c1.get_value("aStr1"), "a") eq_(c1.get_value("aList1"), ["a"]) eq_(c1.get_value("aStr2"), "def2") eq_(c1.get_value("aList2"), []) s1.set_default_value("aStr1", "b") eq_(c1.get_value("aStr1"), "a") c2 = CClass(mcl, "C2", stereotype_instances=s1) eq_(c2.get_value("aStr1"), "b") eq_(c2.get_value("aList1"), ["a"]) eq_(c2.get_value("aStr2"), "def2") eq_(c2.get_value("aList2"), []) eq_(c1.get_value("b"), None) s1.set_default_value("b", True) eq_(c1.get_value("b"), None) c3 = CClass(mcl, "C3", stereotype_instances=s1) eq_(c3.get_value("b"), True)
def test_integers_as_floats(self): mcl = CMetaclass("C", attributes={"floatVal": float}) cl = CClass(mcl, "C") cl.set_value("floatVal", 15) eq_(cl.get_value("floatVal"), 15)
def test_values_multiple_inheritance(self): t1 = CMetaclass("T1") t2 = CMetaclass("T2") st_a = CMetaclass("STA", superclasses=[t1, t2]) sub_a = CMetaclass("SubA", superclasses=[st_a]) st_b = CMetaclass("STB", superclasses=[t1, t2]) sub_b = CMetaclass("SubB", superclasses=[st_b]) st_c = CMetaclass("STC") sub_c = CMetaclass("SubC", superclasses=[st_c]) mcl = CMetaclass("M", superclasses=[sub_a, sub_b, sub_c]) cl = CClass(mcl, "C") 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_(cl.get_value("i0"), 0) eq_(cl.get_value("i1"), 1) eq_(cl.get_value("i2"), 2) eq_(cl.get_value("i3"), 3) eq_(cl.get_value("i4"), 4) eq_(cl.get_value("i5"), 5) eq_(cl.get_value("i6"), 6) eq_(cl.get_value("i7"), 7) eq_(cl.get_value("i0", t1), 0) eq_(cl.get_value("i1", t2), 1) eq_(cl.get_value("i2", st_a), 2) eq_(cl.get_value("i3", sub_a), 3) eq_(cl.get_value("i4", st_b), 4) eq_(cl.get_value("i5", sub_b), 5) eq_(cl.get_value("i6", st_c), 6) eq_(cl.get_value("i7", sub_c), 7) cl.set_value("i0", 10) cl.set_value("i1", 11) cl.set_value("i2", 12) cl.set_value("i3", 13) cl.set_value("i4", 14) cl.set_value("i5", 15) cl.set_value("i6", 16) cl.set_value("i7", 17) eq_(cl.get_value("i0"), 10) eq_(cl.get_value("i1"), 11) eq_(cl.get_value("i2"), 12) eq_(cl.get_value("i3"), 13) eq_(cl.get_value("i4"), 14) eq_(cl.get_value("i5"), 15) eq_(cl.get_value("i6"), 16) eq_(cl.get_value("i7"), 17)
def test_attribute_defined_after_instance(self): mcl = CMetaclass("C") cl = CClass(mcl, "C") mcl.attributes = {"floatVal": float} cl.set_value("floatVal", 15) eq_(cl.get_value("floatVal"), 15)