From e6e005656214e4a0a8a6cd96dabbe4691c2ea593 Mon Sep 17 00:00:00 2001 From: cogu Date: Mon, 22 Jul 2024 19:14:55 +0200 Subject: [PATCH] Implement DataReceivedEvent - Implement DataReceivedEvent - Fixed element names in RModeInAtomicSwcInstanceRef --- CHANGELOG.md | 2 + src/autosar/xml/element.py | 82 ++++++++++++++--- src/autosar/xml/reader.py | 45 +++++++++- src/autosar/xml/writer.py | 51 +++++++++-- tests/xml/test_software_component_elements.py | 20 ++--- tests/xml/test_swc_internal_behavior.py | 90 ++++++++++++++++--- 6 files changed, 246 insertions(+), 44 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4da5d9c9..78e16103 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,9 +12,11 @@ Non-collectable elements are various sub-elements to collectable elements. #### XML - Software component elements * RModeInAtomicSwcInstanceRef | R-MODE-IN-ATOMIC-SWC-INSTANCE-REF +* RVariableInAtomicSwcInstanceRef | R-VARIABLE-IN-ATOMIC-SWC-INSTANCE-REF #### XML - SWC internal behavior elements +* DataReceivedEvent | DATA-RECEIVED-EVENT * InitEvent | INIT-EVENT * InternalBehavior | SWC-INTERNAL-BEHAVIOR (Partly implemented) * RunnableEntity | RUNNABLE-ENTITY diff --git a/src/autosar/xml/element.py b/src/autosar/xml/element.py index f2514ee6..19d43946 100644 --- a/src/autosar/xml/element.py +++ b/src/autosar/xml/element.py @@ -5233,19 +5233,40 @@ class RModeInAtomicSwcInstanceRef(ARObject): """ def __init__(self, - context_port_ref: AbstractRequiredPortPrototypeRef | None = None, - context_mode_declaration_group_prototype_ref: ModeDeclarationGroupPrototypeRef | None = None, - target_mode_declaration_ref: ModeDeclarationRef | None = None, + context_port: AbstractRequiredPortPrototypeRef | None = None, + context_mode_declaration_group_prototype: ModeDeclarationGroupPrototypeRef | None = None, + target_mode_declaration: ModeDeclarationRef | None = None, ) -> None: - self.context_port_ref: AbstractRequiredPortPrototypeRef | None = None # .CONTEXT-PORT-REF + # .CONTEXT-PORT-REF + self.context_port: AbstractRequiredPortPrototypeRef | None = None # .CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF - self.context_mode_declaration_group_prototype_ref: ModeDeclarationGroupPrototypeRef | None = None - self.target_mode_declaration_ref: ModeDeclarationRef | None = None # .TARGET-MODE-DECLARATION-REF - self._assign_optional("context_port_ref", context_port_ref, AbstractRequiredPortPrototypeRef) - self._assign_optional("context_mode_declaration_group_prototype_ref", - context_mode_declaration_group_prototype_ref, + self.context_mode_declaration_group_prototype: ModeDeclarationGroupPrototypeRef | None = None + # .TARGET-MODE-DECLARATION-REF + self.target_mode_declaration: ModeDeclarationRef | None = None + self._assign_optional("context_port", context_port, AbstractRequiredPortPrototypeRef) + self._assign_optional("context_mode_declaration_group_prototype", + context_mode_declaration_group_prototype, ModeDeclarationGroupPrototypeRef) - self._assign_optional("target_mode_declaration_ref", target_mode_declaration_ref, ModeDeclarationRef) + self._assign_optional("target_mode_declaration", target_mode_declaration, ModeDeclarationRef) + + +class RVariableInAtomicSwcInstanceRef(ARObject): + """ + Complex type AR:R-VARIABLE-IN-ATOMIC-SWC-INSTANCE-REF + Tag variants: 'DATA-IREF' + """ + + def __init__(self, + context_port: AbstractRequiredPortPrototypeRef | None = None, + target_data_element: VariableDataPrototypeRef | str | None = None, + ) -> None: + # .CONTEXT-R-PORT-REF (Use same name as in RModeInAtomicSwcInstanceRef for consistency) + self.context_port: AbstractRequiredPortPrototypeRef | None = None + # .TARGET-DATA-ELEMENT-REF + self.target_data_element: VariableDataPrototypeRef | None = None + self._assign_optional("context_port", context_port, AbstractRequiredPortPrototypeRef) + self._assign_optional("target_data_element", target_data_element, VariableDataPrototypeRef) + # --- SWC internal behavior elements @@ -5585,12 +5606,14 @@ class RteEvent(Identifiable): def __init__(self, name: str, - disabled_modes: RModeInAtomicSwcInstanceRef | list[RModeInAtomicSwcInstanceRef] | None = None, start_on_event: RunnableEntityRef | None = None, + disabled_modes: RModeInAtomicSwcInstanceRef | list[RModeInAtomicSwcInstanceRef] | None = None, **kwargs) -> None: super().__init__(name, **kwargs) - self.disabled_modes: list[RModeInAtomicSwcInstanceRef] = [] # .DISABLED-MODE-IREFS - self.start_on_event: RunnableEntityRef | None = None # .START-ON-EVENT-REF + # .DISABLED-MODE-IREFS + self.disabled_modes: list[RModeInAtomicSwcInstanceRef] = [] + # .START-ON-EVENT-REF + self.start_on_event: RunnableEntityRef | None = None if disabled_modes is not None: if isinstance(disabled_modes, RModeInAtomicSwcInstanceRef): self.append_disabled_mode(disabled_modes) @@ -5609,6 +5632,39 @@ def append_disabled_mode(self, disabled_mode: RModeInAtomicSwcInstanceRef) -> No raise TypeError("disabled_mode must be of type RModeInAtomicSwcInstanceRef") +class DataReceivedEvent(RteEvent): + """ + Complex Type AR:DATA-RECEIVED-EVENT + Tag variants: 'DATA-RECEIVED-EVENT' + """ + + def __init__(self, + name: str, + start_on_event: RunnableEntityRef | str | None = None, + data: RVariableInAtomicSwcInstanceRef | None = None, + **kwargs) -> None: + super().__init__(name, start_on_event, **kwargs) + # .DATA-IREF + self.data: RVariableInAtomicSwcInstanceRef | None = None + self._assign_optional_strict("data", data, RVariableInAtomicSwcInstanceRef) + + @classmethod + def make(cls, + name: str, + start_on_event: RunnableEntityRef | str | None = None, + context_port: AbstractRequiredPortPrototypeRef | None = None, + target_data_element: VariableDataPrototypeRef | str | None = None, + **kwargs) -> "DataReceivedEvent": + """ + #convenience-method + + Simplified creation method that automatically creates + and uses the necessary RVariableInAtomicSwcInstanceRef object + """ + data = RVariableInAtomicSwcInstanceRef(context_port, target_data_element) + return cls(name, start_on_event, data, **kwargs) + + class InitEvent(RteEvent): """ Complex Type AR:INIT-EVENT diff --git a/src/autosar/xml/reader.py b/src/autosar/xml/reader.py index 1f2cfa0d..9226dcdd 100644 --- a/src/autosar/xml/reader.py +++ b/src/autosar/xml/reader.py @@ -269,7 +269,9 @@ def __init__(self, 'DISABLED-MODE-IREF': self._read_rmode_in_atomic_swc_instance_ref, 'SWC-INTERNAL-BEHAVIOR': self._read_swc_internal_behavior, 'RUNNABLE-ENTITY': self._read_runnable_entity, + 'DATA-RECEIVED-EVENT': self._read_data_received_event, 'INIT-EVENT': self._read_init_event, + } self.switcher_all = {} self.switcher_all.update(self.switcher_collectable) @@ -4287,17 +4289,35 @@ def _read_rmode_in_atomic_swc_instance_ref(self, child_elements = ChildElementMap(xml_element) xml_child = child_elements.get("CONTEXT-PORT-REF") if xml_child is not None: - data["context_port_ref"] = self._read_abstract_required_port_prototype_ref(xml_child) + data["context_port"] = self._read_abstract_required_port_prototype_ref(xml_child) xml_child = child_elements.get("CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF") if xml_child is not None: child_element = self._read_mode_declaration_group_prototype_ref(xml_child) - data["context_mode_declaration_group_prototype_ref"] = child_element + data["context_mode_declaration_group_prototype"] = child_element xml_child = child_elements.get("TARGET-MODE-DECLARATION-REF") if xml_child is not None: - data["target_mode_declaration_ref"] = self._read_mode_declaration_ref(xml_child) + data["target_mode_declaration"] = self._read_mode_declaration_ref(xml_child) self._report_unprocessed_elements(child_elements) return ar_element.RModeInAtomicSwcInstanceRef(**data) + def _read_rvariable_in_atomic_swc_instance_ref(self, + xml_element: ElementTree.Element + ) -> ar_element.RVariableInAtomicSwcInstanceRef: + """ + Reads complex type AR:R-VARIABLE-IN-ATOMIC-SWC-INSTANCE-REF + Tag variants: 'DATA-IREF' + """ + data = {} + child_elements = ChildElementMap(xml_element) + xml_child = child_elements.get("CONTEXT-R-PORT-REF") + if xml_child is not None: + data["context_port"] = self._read_abstract_required_port_prototype_ref(xml_child) + xml_child = child_elements.get("TARGET-DATA-ELEMENT-REF") + if xml_child is not None: + data["target_data_element"] = self._read_variable_data_prototype_ref(xml_child) + self._report_unprocessed_elements(child_elements) + return ar_element.RVariableInAtomicSwcInstanceRef(**data) + # --- Internal Behavior elements def _read_variable_in_impl_data_instance_ref(self, @@ -4563,6 +4583,25 @@ def _read_rte_event(self, child_elements: ChildElementMap, data: dict) -> None: data["start_on_event"] = self._read_runnable_entity_ref(xml_child) child_elements.skip("VARIATION-POINT") # Not supported + def _read_data_received_event(self, + xml_element: ElementTree.Element + ) -> ar_element.DataReceivedEvent: + """ + Reads complex Type AR:DATA-RECEIVED-EVENT + Tag variants: 'DATA-RECEIVED-EVENT' + """ + data = {} + child_elements = ChildElementMap(xml_element) + self._read_referrable(child_elements, data) + self._read_multi_language_referrable(child_elements, data) + self._read_identifiable(child_elements, xml_element.attrib, data) + self._read_rte_event(child_elements, data) + xml_child = child_elements.get("DATA-IREF") + if xml_child is not None: + data["data"] = self._read_rvariable_in_atomic_swc_instance_ref(xml_child) + self._report_unprocessed_elements(child_elements) + return ar_element.DataReceivedEvent(**data) + def _read_init_event(self, xml_element: ElementTree.Element ) -> ar_element.InitEvent: diff --git a/src/autosar/xml/writer.py b/src/autosar/xml/writer.py index 31907274..6be497e0 100644 --- a/src/autosar/xml/writer.py +++ b/src/autosar/xml/writer.py @@ -340,6 +340,7 @@ def __init__(self, 'ExecutableEntityActivationReason': self._write_executable_entity_activation_reason, 'ExclusiveAreaRefConditional': self._write_exclusive_area_ref_conditional, 'RunnableEntity': self._write_runnable_entity, + 'DataReceivedEvent': self._write_data_received_event, 'InitEvent': self._write_init_event, } @@ -3692,7 +3693,7 @@ def _write_swc_implementation_group(self, elem: ar_element.SwcImplementation) -> def _write_rmode_in_atomic_swc_instance_ref(self, elem: ar_element.RModeInAtomicSwcInstanceRef, tag: str) -> None: """ - Complex type AR:R-MODE-IN-ATOMIC-SWC-INSTANCE-REF + Writes complex type AR:R-MODE-IN-ATOMIC-SWC-INSTANCE-REF Tag variants: 'DISABLED-MODE-IREF' | 'MODE-IREF' """ assert isinstance(elem, ar_element.RModeInAtomicSwcInstanceRef) @@ -3700,16 +3701,35 @@ def _write_rmode_in_atomic_swc_instance_ref(self, elem: ar_element.RModeInAtomic self._add_content(tag) else: self._add_child(tag) - if elem.context_port_ref is not None: - self._write_abstract_required_port_prototype_ref(elem.context_port_ref, "CONTEXT-PORT-REF") - if elem.context_mode_declaration_group_prototype_ref is not None: - self._write_mode_declaration_group_prototype_ref(elem.context_mode_declaration_group_prototype_ref, + if elem.context_port is not None: + self._write_abstract_required_port_prototype_ref(elem.context_port, "CONTEXT-PORT-REF") + if elem.context_mode_declaration_group_prototype is not None: + self._write_mode_declaration_group_prototype_ref(elem.context_mode_declaration_group_prototype, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF") - if elem.target_mode_declaration_ref is not None: - self._write_mode_declaration_ref(elem.target_mode_declaration_ref, "TARGET-MODE-DECLARATION-REF") + if elem.target_mode_declaration is not None: + self._write_mode_declaration_ref(elem.target_mode_declaration, "TARGET-MODE-DECLARATION-REF") self._leave_child() - # SWC Internal behavior elements + def _write_rvariable_in_atomic_swc_instance_ref(self, + elem: ar_element.RVariableInAtomicSwcInstanceRef + ) -> None: + """ + Writes complex type AR:R-VARIABLE-IN-ATOMIC-SWC-INSTANCE-REF + Tag variants: 'DATA-IREF' + """ + assert isinstance(elem, ar_element.RVariableInAtomicSwcInstanceRef) + tag = "DATA-IREF" + if elem.is_empty: + self._add_content(tag) + else: + self._add_child(tag) + if elem.context_port is not None: + self._write_abstract_required_port_prototype_ref(elem.context_port, "CONTEXT-R-PORT-REF") + if elem.target_data_element is not None: + self._write_variable_data_prototype_ref(elem.target_data_element, "TARGET-DATA-ELEMENT-REF") + self._leave_child() + + # --- SWC Internal behavior elements def _write_variable_in_impl_data_instance_ref(self, elem: ar_element.ArVariableInImplementationDataInstanceRef, @@ -3917,6 +3937,21 @@ def _write_rte_event(self, elem: ar_element.RteEvent) -> None: if elem.start_on_event is not None: self._write_runnable_entity_ref(elem.start_on_event, "START-ON-EVENT-REF") + def _write_data_received_event(self, elem: ar_element.DataReceivedEvent) -> None: + """ + Writes complex Type AR:DATA-RECEIVED-EVENT + Tag variants: 'DATA-RECEIVED-EVENT' + """ + assert isinstance(elem, ar_element.DataReceivedEvent) + self._add_child("DATA-RECEIVED-EVENT") + self._write_referrable(elem) + self._write_multilanguage_referrable(elem) + self._write_identifiable(elem) + self._write_rte_event(elem) + if elem.data is not None: + self._write_rvariable_in_atomic_swc_instance_ref(elem.data) + self._leave_child() + def _write_init_event(self, elem: ar_element.InitEvent) -> None: """ Writes complex type AR:INIT-EVENT diff --git a/tests/xml/test_software_component_elements.py b/tests/xml/test_software_component_elements.py index 475e0baa..d94b92b3 100644 --- a/tests/xml/test_software_component_elements.py +++ b/tests/xml/test_software_component_elements.py @@ -2066,10 +2066,10 @@ def test_empty(self): elem: ar_element.RModeInAtomicSwcInstanceRef = reader.read_str_elem(xml) self.assertIsInstance(elem, ar_element.RModeInAtomicSwcInstanceRef) - def test_context_port_ref(self): + def test_context_port(self): ref_str = "/Components/ComponentName/RequirePortName" port_ref = ar_element.PortPrototypeRef(ref_str, ar_enum.IdentifiableSubTypes.R_PORT_PROTOTYPE) - element = ar_element.RModeInAtomicSwcInstanceRef(context_port_ref=port_ref) + element = ar_element.RModeInAtomicSwcInstanceRef(context_port=port_ref) writer = autosar.xml.Writer() xml = f''' {ref_str} @@ -2078,13 +2078,13 @@ def test_context_port_ref(self): reader = autosar.xml.Reader() elem: ar_element.RModeInAtomicSwcInstanceRef = reader.read_str_elem(xml) self.assertIsInstance(elem, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(elem.context_port_ref), ref_str) - self.assertEqual(elem.context_port_ref.dest, ar_enum.IdentifiableSubTypes.R_PORT_PROTOTYPE) + self.assertEqual(str(elem.context_port), ref_str) + self.assertEqual(elem.context_port.dest, ar_enum.IdentifiableSubTypes.R_PORT_PROTOTYPE) - def test_context_mode_declaration_group_prototype_ref(self): + def test_context_mode_declaration_group_prototype(self): ref_str = "/ModeDeclarationGroups/ModeDeclarationGroupName" mode_decl_ref = ar_element.ModeDeclarationGroupPrototypeRef(ref_str) - element = ar_element.RModeInAtomicSwcInstanceRef(context_mode_declaration_group_prototype_ref=mode_decl_ref) + element = ar_element.RModeInAtomicSwcInstanceRef(context_mode_declaration_group_prototype=mode_decl_ref) writer = autosar.xml.Writer() tag = "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF" xml = f''' @@ -2094,12 +2094,12 @@ def test_context_mode_declaration_group_prototype_ref(self): reader = autosar.xml.Reader() elem: ar_element.RModeInAtomicSwcInstanceRef = reader.read_str_elem(xml) self.assertIsInstance(elem, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(elem.context_mode_declaration_group_prototype_ref), ref_str) + self.assertEqual(str(elem.context_mode_declaration_group_prototype), ref_str) - def test_target_mode_declaration_ref(self): + def test_target_mode_declaration(self): ref_str = "/ModeDeclarationGroups/ModeDeclarationGroupName/ModeName" mode_ref = ar_element.ModeDeclarationRef(ref_str) - element = ar_element.RModeInAtomicSwcInstanceRef(target_mode_declaration_ref=mode_ref) + element = ar_element.RModeInAtomicSwcInstanceRef(target_mode_declaration=mode_ref) writer = autosar.xml.Writer() xml = f''' {ref_str} @@ -2108,7 +2108,7 @@ def test_target_mode_declaration_ref(self): reader = autosar.xml.Reader() elem: ar_element.RModeInAtomicSwcInstanceRef = reader.read_str_elem(xml) self.assertIsInstance(elem, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(elem.target_mode_declaration_ref), ref_str) + self.assertEqual(str(elem.target_mode_declaration), ref_str) if __name__ == '__main__': diff --git a/tests/xml/test_swc_internal_behavior.py b/tests/xml/test_swc_internal_behavior.py index 9cf14d7d..b66ffb74 100644 --- a/tests/xml/test_swc_internal_behavior.py +++ b/tests/xml/test_swc_internal_behavior.py @@ -739,9 +739,9 @@ def test_disabled_modes_from_element(self): context_mode_decl_group = ar_element.ModeDeclarationGroupPrototypeRef(context_mode_decl_group_ref_str) target_mode_decl = ar_element.ModeDeclarationRef(target_mode_decl_ref_str) disabled_mode = ar_element.RModeInAtomicSwcInstanceRef( - context_port_ref=context_port, - context_mode_declaration_group_prototype_ref=context_mode_decl_group, - target_mode_declaration_ref=target_mode_decl) + context_port=context_port, + context_mode_declaration_group_prototype=context_mode_decl_group, + target_mode_declaration=target_mode_decl) element = ar_element.InitEvent('MyName', disabled_modes=disabled_mode) writer = autosar.xml.Writer() @@ -763,7 +763,7 @@ def test_disabled_modes_from_element(self): self.assertEqual(len(elem.disabled_modes), 1) child = elem.disabled_modes[0] self.assertIsInstance(child, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(child.target_mode_declaration_ref), target_mode_decl_ref_str) + self.assertEqual(str(child.target_mode_declaration), target_mode_decl_ref_str) def test_disabled_modes_from_list(self): context_port_ref_str = "/ComponentTypes/MyComponent/BswM_Mode" @@ -779,9 +779,9 @@ def test_disabled_modes_from_list(self): context_mode_decl_group = ar_element.ModeDeclarationGroupPrototypeRef(context_mode_decl_group_ref_str) target_mode_decl = ar_element.ModeDeclarationRef(target_mode_decl_ref) disabled_modes.append(ar_element.RModeInAtomicSwcInstanceRef( - context_port_ref=context_port, - context_mode_declaration_group_prototype_ref=context_mode_decl_group, - target_mode_declaration_ref=target_mode_decl)) + context_port=context_port, + context_mode_declaration_group_prototype=context_mode_decl_group, + target_mode_declaration=target_mode_decl)) element = ar_element.InitEvent('MyName', disabled_modes=disabled_modes) writer = autosar.xml.Writer() @@ -815,13 +815,13 @@ def test_disabled_modes_from_list(self): self.assertEqual(len(elem.disabled_modes), 3) child = elem.disabled_modes[0] self.assertIsInstance(child, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(child.target_mode_declaration_ref), target_mode_decl_refs[0]) + self.assertEqual(str(child.target_mode_declaration), target_mode_decl_refs[0]) child = elem.disabled_modes[1] self.assertIsInstance(child, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(child.target_mode_declaration_ref), target_mode_decl_refs[1]) + self.assertEqual(str(child.target_mode_declaration), target_mode_decl_refs[1]) child = elem.disabled_modes[2] self.assertIsInstance(child, ar_element.RModeInAtomicSwcInstanceRef) - self.assertEqual(str(child.target_mode_declaration_ref), target_mode_decl_refs[2]) + self.assertEqual(str(child.target_mode_declaration), target_mode_decl_refs[2]) def test_start_on_event(self): ref_str = '/ComponentTypes/MyComponent/MyComponent_InternalBehavior/MyComponent_Init' @@ -839,6 +839,76 @@ def test_start_on_event(self): self.assertEqual(str(elem.start_on_event), ref_str) +class TestDataReceivedEvent(unittest.TestCase): + """ + Base elements are tested in TestInitEvent + """ + + def test_name_only(self): + element = ar_element.DataReceivedEvent('MyName') + writer = autosar.xml.Writer() + xml = ''' + MyName +''' + self.assertEqual(writer.write_str_elem(element), xml) + reader = autosar.xml.Reader() + elem: ar_element.DataReceivedEvent = reader.read_str_elem(xml) + self.assertIsInstance(elem, ar_element.DataReceivedEvent) + self.assertEqual(elem.name, 'MyName') + + def test_data_from_element(self): + context_port_ref_str = "/ComponentTypes/MyComponent/CurrentWorkload" + target_data_element_str = "/PortInterfaces/CurrentWorkload_I/CurrentWorkload" + context_port = ar_element.PortPrototypeRef(context_port_ref_str, ar_enum.IdentifiableSubTypes.R_PORT_PROTOTYPE) + target_data_element = ar_element.VariableDataPrototypeRef(target_data_element_str) + data = ar_element.RVariableInAtomicSwcInstanceRef(context_port=context_port, + target_data_element=target_data_element) + element = ar_element.DataReceivedEvent('MyName', + data=data) + xml = f''' + MyName + + {context_port_ref_str} + {target_data_element_str} + +''' + writer = autosar.xml.Writer() + self.assertEqual(writer.write_str_elem(element), xml) + reader = autosar.xml.Reader() + elem: ar_element.DataReceivedEvent = reader.read_str_elem(xml) + self.assertIsInstance(elem, ar_element.DataReceivedEvent) + inner: ar_element.RVariableInAtomicSwcInstanceRef = elem.data + self.assertEqual(str(inner.context_port), context_port_ref_str) + self.assertEqual(str(inner.target_data_element), target_data_element_str) + + def test_create_using_conveneince_method(self): + start_on_event_ref_str = "/ComponentTypes/MyComponent/InternalBehavior/MyRunnable" + context_port_ref_str = "/ComponentTypes/MyComponent/CurrentWorkload" + target_data_element_str = "/PortInterfaces/CurrentWorkload_I/CurrentWorkload" + context_port = ar_element.PortPrototypeRef(context_port_ref_str, ar_enum.IdentifiableSubTypes.R_PORT_PROTOTYPE) + element = ar_element.DataReceivedEvent.make('MyName', + start_on_event_ref_str, + context_port, + target_data_element_str) + xml = f''' + MyName + {start_on_event_ref_str} + + {context_port_ref_str} + {target_data_element_str} + +''' + writer = autosar.xml.Writer() + self.assertEqual(writer.write_str_elem(element), xml) + reader = autosar.xml.Reader() + elem: ar_element.DataReceivedEvent = reader.read_str_elem(xml) + self.assertEqual(str(elem.start_on_event), start_on_event_ref_str) + self.assertIsInstance(elem, ar_element.DataReceivedEvent) + inner: ar_element.RVariableInAtomicSwcInstanceRef = elem.data + self.assertEqual(str(inner.context_port), context_port_ref_str) + self.assertEqual(str(inner.target_data_element), target_data_element_str) + + class TestSwcInternalBehavior(unittest.TestCase): """ Most elements are not implemented yet