def test_parse_operation(factory): """Test parsing simple operation.""" o = factory.create(UML.Operation) UML.parse(o, "myfunc()") assert "myfunc" == o.name assert not o.returnResult[0].typeValue assert not o.formalParameter
def test_association_notification(self): """ Test notifications with Class object. Tricky case where no events are fired. """ dispatcher = self.dispatcher element = UML.Association() p1 = element.memberEnd = UML.Property() p2 = element.memberEnd = UML.Property() assert len(element.memberEnd) == 2 print(element.memberEnd) dispatcher.register_handler(self._handler, element, 'memberEnd.name') assert len(dispatcher._handlers) == 3, len(dispatcher._handlers) assert not self.events p1.name = 'foo' assert len(self.events) == 1, (self.events, dispatcher._handlers) assert len(dispatcher._handlers) == 3 p1.name = 'othername' assert len(self.events) == 2, self.events p1.name = 'othername' assert len(self.events) == 2, self.events
def test_register_handler_twice(self): """ Multiple registrations have no effect. """ dispatcher = self.dispatcher element = UML.Class() # Add some properties: element.ownedOperation = UML.Operation() p = element.ownedOperation[0].formalParameter = UML.Parameter() dispatcher.register_handler(self._handler, element, 'ownedOperation.parameter.name') n_handlers = len(dispatcher._handlers) self.assertEquals(0, len(self.events)) dispatcher.register_handler(self._handler, element, 'ownedOperation.parameter.name') self.assertEquals(n_handlers, len(dispatcher._handlers)) dispatcher.register_handler(self._handler, element, 'ownedOperation.parameter.name') self.assertEquals(n_handlers, len(dispatcher._handlers)) dispatcher.register_handler(self._handler, element, 'ownedOperation.parameter.name') self.assertEquals(n_handlers, len(dispatcher._handlers)) p.name = 'func' self.assertEquals(1, len(self.events))
def test_parse_operation(self): """Test parsing simple operation """ o = factory.create(UML.Operation) UML.parse(o, "myfunc()") self.assertEqual("myfunc", o.name) self.assertTrue(not o.returnResult[0].typeValue) self.assertFalse(o.formalParameter)
def test_parse_operation(self): """Test parsing simple operation """ o = factory.create(UML.Operation) UML.parse(o, 'myfunc()') self.assertEquals('myfunc', o.name) self.assertTrue(not o.returnResult[0].typeValue) self.assertFalse(o.formalParameter)
def test_parse_operation_return(factory): """Test parsing operation with return value.""" o = factory.create(UML.Operation) UML.parse(o, "+ myfunc(): int") assert "myfunc" == o.name assert "int" == o.returnResult[0].typeValue assert "public" == o.visibility assert not o.formalParameter
def test_parse_operation_return(self): """Test parsing operation with return value """ o = factory.create(UML.Operation) UML.parse(o, "+ myfunc(): int") self.assertEqual("myfunc", o.name) self.assertEqual("int", o.returnResult[0].typeValue) self.assertEqual("public", o.visibility) self.assertTrue(not o.formalParameter)
def test_parse_operation_return(self): """Test parsing operation with return value """ o = factory.create(UML.Operation) UML.parse(o, '+ myfunc(): int') self.assertEquals('myfunc', o.name) self.assertEquals('int', o.returnResult[0].typeValue) self.assertEquals('public', o.visibility) self.assertTrue(not o.formalParameter)
def test_parse_property_simple(factory): """Test simple property parsing.""" a = factory.create(UML.Property) UML.parse(a, "myattr") assert not a.isDerived assert "myattr" == a.name assert a.typeValue is None, a.typeValue assert a.lowerValue is None, a.lowerValue assert a.upperValue is None, a.upperValue assert a.defaultValue is None, a.defaultValue
def test_parse_property_simple(self): """Test simple property parsing """ a = factory.create(UML.Property) UML.parse(a, 'myattr') self.assertFalse(a.isDerived) self.assertEquals('myattr', a.name) self.assertTrue(a.typeValue is None, a.typeValue) self.assertTrue(a.lowerValue is None, a.lowerValue) self.assertTrue(a.upperValue is None, a.upperValue) self.assertTrue(a.defaultValue is None, a.defaultValue)
def test_parse_operation_1_param(factory): """Test parsing of operation with one parameter.""" o = factory.create(UML.Operation) UML.parse(o, "- myfunc2 (a: node): double") assert "myfunc2" == o.name assert "double" == o.returnResult[0].typeValue assert "private" == o.visibility assert len(o.formalParameter) == 1 assert "a" == o.formalParameter[0].name assert "node" == o.formalParameter[0].typeValue assert o.formalParameter[0].defaultValue is None
def test_parse_property_simple(self): """Test simple property parsing """ a = factory.create(UML.Property) UML.parse(a, "myattr") self.assertFalse(a.isDerived) self.assertEqual("myattr", a.name) self.assertTrue(a.typeValue is None, a.typeValue) self.assertTrue(a.lowerValue is None, a.lowerValue) self.assertTrue(a.upperValue is None, a.upperValue) self.assertTrue(a.defaultValue is None, a.defaultValue)
def test_parse_association_end_multiplicity(factory): """Test parsing of multiplicity.""" a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "0..2 { tag }") assert p.name is None assert not p.typeValue assert "0" == p.lowerValue assert "2" == p.upperValue assert not p.defaultValue
def test_parse_property_invalid(factory): """Test parsing property with invalid syntax.""" a = factory.create(UML.Property) UML.parse(a, '+ name = str[*] = "aap" { static }') assert '+ name = str[*] = "aap" { static }' == a.name assert not a.isDerived assert not a.typeValue assert not a.lowerValue assert not a.upperValue assert not a.defaultValue
def _set_object_value(self, row, col, value): attr = row[-1] if col == 0: UML.parse(attr, value) row[0] = UML.format(attr) elif col == 1: attr.isStatic = not attr.isStatic row[1] = attr.isStatic elif col == 2: # Value in attribute object changed: row[0] = UML.format(attr) row[1] = attr.isStatic
def test_parse_multiplicity(self): """Test parsing of multiplicity """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "0..2 { tag }") self.assertTrue(p.name is None) self.assertTrue(not p.typeValue) self.assertEqual("0", p.lowerValue) self.assertEqual("2", p.upperValue) self.assertTrue(not p.defaultValue)
def test_parse_operation_1_param(self): """Test parsing of operation with one parameter """ o = factory.create(UML.Operation) UML.parse(o, "- myfunc2 (a: node): double") self.assertEqual("myfunc2", o.name) self.assertEqual("double", o.returnResult[0].typeValue) self.assertEqual("private", o.visibility) self.assertEqual(1, len(o.formalParameter)) self.assertEqual("a", o.formalParameter[0].name) self.assertEqual("node", o.formalParameter[0].typeValue) self.assertTrue(o.formalParameter[0].defaultValue is None)
def test_parse_property_complex(factory): """Test complex property parsing.""" a = factory.create(UML.Property) UML.parse(a, '+ / name : str[0..*] = "aap" { static }') assert "public" == a.visibility assert a.isDerived assert "name" == a.name assert "str" == a.typeValue assert "0" == a.lowerValue assert "*" == a.upperValue assert '"aap"' == a.defaultValue
def test_parse_association_end(factory): """Test parsing of association end.""" a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "end") assert "end" == p.name assert not p.typeValue assert not p.lowerValue assert not p.upperValue assert not p.defaultValue
def test_operation_parameter_deletion(factory): assert 0 == len(factory.lselect()) c = factory.create(UML.Class) c.name = "Class" o = factory.create(UML.Operation) c.ownedOperation = o UML.parse(o, "a(x: int, y: int)") c.unlink() assert 0 == len(factory.lselect()), factory.lselect()
def test_parse_property_invalid(self): """Test parsing property with invalid syntax """ a = factory.create(UML.Property) UML.parse(a, '+ name = str[*] = "aap" { static }') self.assertEqual('+ name = str[*] = "aap" { static }', a.name) self.assertFalse(a.isDerived) self.assertTrue(not a.typeValue) self.assertTrue(not a.lowerValue) self.assertTrue(not a.upperValue) self.assertTrue(not a.defaultValue)
def test_parse_property_invalid(self): """Test parsing property with invalid syntax """ a = factory.create(UML.Property) UML.parse(a, '+ name = str[*] = "aap" { static }') self.assertEquals('+ name = str[*] = "aap" { static }', a.name) self.assertFalse(a.isDerived) self.assertTrue(not a.typeValue) self.assertTrue(not a.lowerValue) self.assertTrue(not a.upperValue) self.assertTrue(not a.defaultValue)
def test_parse_multiplicity2(self): """Test parsing of multiplicity with multiline constraints """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "0..2 { tag1, \ntag2}") self.assertTrue(p.name is None) self.assertTrue(not p.typeValue) self.assertEqual("0", p.lowerValue) self.assertEqual("2", p.upperValue) self.assertTrue(not p.defaultValue)
def test_parse_operation_1_param(self): """Test parsing of operation with one parameter """ o = factory.create(UML.Operation) UML.parse(o, '- myfunc2 (a: node): double') self.assertEquals('myfunc2', o.name) self.assertEquals('double', o.returnResult[0].typeValue) self.assertEquals('private', o.visibility) self.assertEquals(1, len(o.formalParameter)) self.assertEquals('a', o.formalParameter[0].name) self.assertEquals('node', o.formalParameter[0].typeValue) self.assertTrue(o.formalParameter[0].defaultValue is None)
def test_parse_multiplicity2(self): """Test parsing of multiplicity with multiline constraints """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, '0..2 { tag1, \ntag2}') self.assertTrue(p.name is None) self.assertTrue(not p.typeValue) self.assertEquals('0', p.lowerValue) self.assertEquals('2', p.upperValue) self.assertTrue(not p.defaultValue)
def test_qualified_name(): p1 = UML.Package() p2 = UML.Package() p3 = UML.Package() p1.name = "package1" p2.name = "package2" p3.name = "package3" p3.package = p2 p2.package = p1 assert p3.qualifiedName == ["package1", "package2", "package3"]
def test_parse_multiplicity(self): """Test parsing of multiplicity """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "0..2 { tag }") self.assertTrue(p.name is None) self.assertTrue(not p.typeValue) self.assertEquals("0", p.lowerValue.value) self.assertEquals("2", p.upperValue.value) self.assertTrue(not p.defaultValue)
def test_parse_association_end(self): """Test parsing of association end """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "end") self.assertEqual("end", p.name) self.assertTrue(not p.typeValue) self.assertTrue(not p.lowerValue) self.assertTrue(not p.upperValue) self.assertTrue(not p.defaultValue)
def test_operation_parameter_deletion(self): factory = UML.ElementFactory() self.assertEquals(0, len(factory.lselect())) c = factory.create(UML.Class) c.name = 'Class' o = factory.create(UML.Operation) c.ownedOperation = o UML.parse(o, 'a(x: int, y: int)') c.unlink() self.assertEquals(0, len(factory.lselect()), factory.lselect())
def test_parse_association_end(self): """Test parsing of association end """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, 'end') self.assertEquals('end', p.name) self.assertTrue(not p.typeValue) self.assertTrue(not p.lowerValue) self.assertTrue(not p.upperValue) self.assertTrue(not p.defaultValue)
def test_parse_association_end_derived_end(factory): """Test parsing derived association end.""" a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "-/end[*] { mytag}") assert "private" == p.visibility assert p.isDerived assert "end" == p.name assert not p.typeValue assert not p.lowerValue assert "*" == p.upperValue assert not p.defaultValue
def test_class_with_attributes(diagram, element_factory): cls = element_factory.create(UML.Class) attr = element_factory.create(UML.Property) UML.parse(attr, "- attr: str") cls.ownedAttribute = attr cls_item = diagram.create(ClassItem, subject=cls) new_items = copy_clear_and_paste({cls_item}, diagram, element_factory) new_cls_item = new_items.pop() assert isinstance(new_cls_item, ClassItem) assert UML.format(new_cls_item.subject.ownedAttribute[0]) == "- attr: str"
def test_parse_property_complex(self): """Test complex property parsing """ a = factory.create(UML.Property) UML.parse(a, '+ / name : str[0..*] = "aap" { static }') self.assertEqual("public", a.visibility) self.assertTrue(a.isDerived) self.assertEqual("name", a.name) self.assertEqual("str", a.typeValue) self.assertEqual("0", a.lowerValue) self.assertEqual("*", a.upperValue) self.assertEqual('"aap"', a.defaultValue)
def test_parse_property_complex(self): """Test complex property parsing """ a = factory.create(UML.Property) UML.parse(a, '+ / name : str[0..*] = "aap" { static }') self.assertEquals('public', a.visibility) self.assertTrue(a.isDerived) self.assertEquals('name', a.name) self.assertEquals('str', a.typeValue) self.assertEquals('0', a.lowerValue) self.assertEquals('*', a.upperValue) self.assertEquals('"aap"', a.defaultValue)
def test_parse_operation_2_params(factory): """Test parsing of operation with two parameters.""" o = factory.create(UML.Operation) UML.parse(o, "# myfunc2 (a: str, b: int = 3 { static}): float") assert "myfunc2" == o.name assert "float" == o.returnResult[0].typeValue assert "protected" == o.visibility assert len(o.formalParameter) == 2 assert "a" == o.formalParameter[0].name assert "str" == o.formalParameter[0].typeValue assert o.formalParameter[0].defaultValue is None assert "b" == o.formalParameter[1].name assert "int" == o.formalParameter[1].typeValue assert "3" == o.formalParameter[1].defaultValue
def test_parse_derived_end(self): """Test parsing derived association end """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, "-/end[*] { mytag}") self.assertEqual("private", p.visibility) self.assertTrue(p.isDerived) self.assertEqual("end", p.name) self.assertTrue(not p.typeValue) self.assertTrue(not p.lowerValue) self.assertEqual("*", p.upperValue) self.assertTrue(not p.defaultValue)
def test_parse_derived_end(self): """Test parsing derived association end """ a = factory.create(UML.Association) p = factory.create(UML.Property) p.association = a UML.parse(p, '-/end[*] { mytag}') self.assertEquals('private', p.visibility) self.assertTrue(p.isDerived) self.assertEquals('end', p.name) self.assertTrue(not p.typeValue) self.assertTrue(not p.lowerValue) self.assertEquals('*', p.upperValue) self.assertTrue(not p.defaultValue)
def test_class_with_operation(diagram, element_factory): cls = element_factory.create(UML.Class) oper = element_factory.create(UML.Operation) UML.parse(oper, "- oper(inout param: str): str") cls.ownedOperation = oper cls_item = diagram.create(ClassItem, subject=cls) new_items = copy_clear_and_paste({cls_item}, diagram, element_factory) new_cls_item = new_items.pop() assert isinstance(new_cls_item, ClassItem) assert (UML.format(new_cls_item.subject.ownedOperation[0]) == "- oper(inout param: str): str")
def test_parse_operation_2_params(self): """Test parsing of operation with two parameters """ o = factory.create(UML.Operation) UML.parse(o, '# myfunc2 (a: str, b: int = 3 { static}): float') self.assertEquals('myfunc2', o.name) self.assertEquals('float', o.returnResult[0].typeValue) self.assertEquals('protected', o.visibility) self.assertEquals(2, len(o.formalParameter)) self.assertEquals('a', o.formalParameter[0].name) self.assertEquals('str', o.formalParameter[0].typeValue) self.assertTrue(o.formalParameter[0].defaultValue is None) self.assertEquals('b', o.formalParameter[1].name) self.assertEquals('int', o.formalParameter[1].typeValue) self.assertEquals('3', o.formalParameter[1].defaultValue)
def _set_object_value(self, row, col, value): operation = row[-1] if col == 0: UML.parse(operation, value) row[0] = UML.format(operation) elif col == 1: operation.isAbstract = not operation.isAbstract row[1] = operation.isAbstract elif col == 2: operation.isStatic = not operation.isStatic row[2] = operation.isStatic elif col == 3: row[0] = UML.format(operation) row[1] = operation.isAbstract row[2] = operation.isStatic
def test_parse_operation_2_params(self): """Test parsing of operation with two parameters """ o = factory.create(UML.Operation) UML.parse(o, "# myfunc2 (a: str, b: int = 3 { static}): float") self.assertEqual("myfunc2", o.name) self.assertEqual("float", o.returnResult[0].typeValue) self.assertEqual("protected", o.visibility) self.assertEqual(2, len(o.formalParameter)) self.assertEqual("a", o.formalParameter[0].name) self.assertEqual("str", o.formalParameter[0].typeValue) self.assertTrue(o.formalParameter[0].defaultValue is None) self.assertEqual("b", o.formalParameter[1].name) self.assertEqual("int", o.formalParameter[1].typeValue) self.assertEqual("3", o.formalParameter[1].defaultValue)
def handler(event): if not entry.props.has_focus: entry.handler_block(changed_id) entry.set_text(UML.format(self.subject, visibility=True, is_derived=True, multiplicity=True) or '') #entry.set_text(UML.format(self.subject, multiplicity=True) or '') entry.handler_unblock(changed_id)
def render(self): """Render the OperationItem.""" return UML.format(self.subject,\ visibility=True,\ type=True,\ multiplicity=True,\ default=True) or ''
def get_text(self): if self._edit is self._item: return self._edit.subject.name return UML.format( self._edit.subject, visibility=True, is_derived=True, type=True, multiplicity=True, default=True, )
def testAttribute(self): """ Test how attribute is updated """ attr = self.element_factory.create(UML.Property) UML.parse(attr, '-name:myType') clazzitem = self.create(ClassItem, UML.Class) clazzitem.subject.ownedAttribute = attr self.assertEquals(1, len(clazzitem._compartments[0])) item = clazzitem._compartments[0][0] self.assertTrue(isinstance(item, FeatureItem)) size = item.get_size() self.assertNotEquals((0, 0), size) attr.defaultValue = 'myDefault' self.diagram.canvas.update() self.assertTrue(size < item.get_size())
def set_text(self): """ Set the text on the association end. """ if self.subject: try: n, m = UML.format(self.subject) except ValueError: # need more than 0 values to unpack: property was rendered as # attribute while in a UNDO action for example. pass else: self._name = n self._mult = m self.request_update()
def get_text(self): return UML.format(editable(self._edit.subject))
def _on_end_name_change(self, entry): UML.parse(self.subject, entry.get_text())
def _get_rows(self): for attr in self._item.subject.ownedAttribute: if not attr.association: yield [UML.format(attr), attr.isStatic, attr]
def _get_rows(self): for operation in self._item.subject.ownedOperation: yield [UML.format(operation), operation.isAbstract, operation.isStatic, operation]
def test_parse_operation_invalid_syntax(self): """Test operation parsing with invalid syntax """ o = factory.create(UML.Operation) UML.parse(o, "- myfunc2: myType2") self.assertEqual("- myfunc2: myType2", o.name)
def render(self): """ Return a rendered feature, as a string. """ return UML.format(self.subject, pattern=self.pattern) or ''
def update_text(self, text): UML.parse(editable(self._edit.subject), text)
def update_text(self, text): UML.parse(self._edit.subject, text)