armodel 1.4.0__py3-none-any.whl → 1.4.3__py3-none-any.whl

armodel/tests/test_armodel/parser/test_parse_bswmd.py

@@ -1,11 +1,21 @@
+import filecmp
+
 from .... import AUTOSAR, ARPackage
-from .... import ARXMLParser
+from .... import ARXMLParser, ARXMLWriter
 
 import logging
 
 class TestBswMD:
     def setup_method(self):
+        logger = logging.getLogger()
+        formatter = logging.Formatter('[%(levelname)s] : %(message)s')
         logging.basicConfig(format='[%(levelname)s] : %(message)s', level = logging.DEBUG)
+        log_file = 'pytest_armodel.log'
+
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)
+        logger.addHandler(file_handler)
 
         document = AUTOSAR.getInstance()
         document.clear()
@@ -37,14 +47,15 @@ class TestBswMD:
 
         bsw_module_desc = bsw_module_descs[0]
         assert(bsw_module_desc.short_name == "BswM")
-        assert(bsw_module_desc.module_id == 42)
+        assert(bsw_module_desc.module_id.getText() == "34")
+        assert(bsw_module_desc.module_id.getValue() == 34)
 
         # verify the provided entries
-        assert(len(bsw_module_desc.implemented_entry_refs) == 2)
-        assert(bsw_module_desc.implemented_entry_refs[0].dest == "BSW-MODULE-ENTRY")
-        assert(bsw_module_desc.implemented_entry_refs[0].value == "/AUTOSAR_BswM/BswModuleEntrys/BswM_MainFunction")
-        assert(bsw_module_desc.implemented_entry_refs[1].dest == "BSW-MODULE-ENTRY")
-        assert(bsw_module_desc.implemented_entry_refs[1].value == "/AUTOSAR_BswM/BswModuleEntrys/BswM_Init")
+        assert(len(bsw_module_desc._implementedEntryRefs) == 2)
+        assert(bsw_module_desc._implementedEntryRefs[0].dest == "BSW-MODULE-ENTRY")
+        assert(bsw_module_desc._implementedEntryRefs[0].value == "/AUTOSAR_BswM/BswModuleEntrys/BswM_Init")
+        assert(bsw_module_desc._implementedEntryRefs[1].dest == "BSW-MODULE-ENTRY")
+        assert(bsw_module_desc._implementedEntryRefs[1].value == "/AUTOSAR_BswM/BswModuleEntrys/BswM_MainFunction")
 
         assert(len(bsw_module_desc.getBswInternalBehaviors()) == 1)
         behavior = bsw_module_desc.getBswInternalBehaviors()[0]
@@ -61,9 +72,9 @@ class TestBswMD:
         assert(len(behavior.getBswSchedulableEntities()) == 1)
         entity = behavior.getBswSchedulableEntities()[0]
         assert(entity.short_name == "BswM_MainFunction")
-        assert(entity.minimum_start_interval == 0)
-        assert(entity.minimum_start_interval_ms == 0)
-        assert(len(entity.getCanEnterExclusiveAreaRefs()) == 1)
+        assert(entity.minimum_start_interval is not None)
+        assert(entity.minimum_start_interval_ms is not None)
+        assert(len(entity.getCanEnterExclusiveAreaRefs()) == 1) 
         assert(entity.getCanEnterExclusiveAreaRefs()[0].dest == "EXCLUSIVE-AREA")
         assert(entity.getCanEnterExclusiveAreaRefs()[0].value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/SCHM_BSWM_EXCLUSIVE_AREA")
         assert(entity.implemented_entry_ref.dest == "BSW-MODULE-ENTRY")
@@ -72,10 +83,11 @@ class TestBswMD:
         assert(len(behavior.getBswTimingEvents()) == 1)
         event = behavior.getBswTimingEvents()[0]
         assert(event.short_name == "TimingEvent_MainFunction")
-        assert(event.starts_on_event_ref.dest == "BSW-SCHEDULABLE-ENTITY")
-        assert(event.starts_on_event_ref.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/BswM_MainFunction")
-        assert(event.period == 0.02)
-        assert(event.period_ms == 20)
+        assert(event.startsOnEventRef.dest == "BSW-SCHEDULABLE-ENTITY")
+        assert(event.startsOnEventRef.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/BswM_MainFunction")
+        assert(event.period.getValue() == 0.02)
+        assert(event.period.getText() == "0.02")
+        assert(event.periodMs == 20)
 
     def test_bsw_module_entries(self):
         document = AUTOSAR.getInstance()
@@ -85,20 +97,20 @@ class TestBswMD:
         assert(len(entries) == 2)
 
         assert(entries[0].short_name == "BswM_Init")
-        assert(entries[0].service_id == 0)
+        assert(entries[0].service_id._value == 0)
         assert(entries[0].is_reentrant.value == False)
         assert(entries[0].is_synchronous.value == True)
-        assert(entries[0].call_type == "REGULAR")
-        assert(entries[0].execution_context == "UNSPECIFIED")
-        assert(entries[0].sw_service_impl_policy == "STANDARD")
+        assert(entries[0].call_type.getText() == "REGULAR")
+        assert(entries[0].execution_context.getText() == "UNSPECIFIED")
+        assert(entries[0].sw_service_impl_policy.getText() == "STANDARD")
 
         assert(entries[1].short_name == "BswM_MainFunction")
-        assert(entries[1].service_id == 3)
+        assert(entries[1].service_id._value == 3)
         assert(entries[1].is_reentrant.value == False)
         assert(entries[1].is_synchronous.value == True)
-        assert(entries[1].call_type == "SCHEDULED")
-        assert(entries[1].execution_context == "TASK")
-        assert(entries[1].sw_service_impl_policy == "STANDARD")
+        assert(entries[1].call_type.getText() == "SCHEDULED")
+        assert(entries[1].execution_context.getText() == "TASK")
+        assert(entries[1].sw_service_impl_policy.getText() == "STANDARD")
 
     def test_bsw_module_swc_bsw_mapping(self):
         document = AUTOSAR.getInstance()
@@ -107,15 +119,15 @@ class TestBswMD:
         mappings = pkg.getSwcBswMappings()
         assert(len(mappings) == 1)
 
-        assert(mappings[0].bsw_behavior_ref.dest == "BSW-INTERNAL-BEHAVIOR")
-        assert(mappings[0].bsw_behavior_ref.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
+        assert(mappings[0].bswBehaviorRef.dest == "BSW-INTERNAL-BEHAVIOR")
+        assert(mappings[0].bswBehaviorRef.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
         
         assert(len(mappings[0].getRunnableMappings()) == 1)
         runnable_mapping = mappings[0].getRunnableMappings()[0]
-        assert(runnable_mapping.bsw_entity_ref.dest == "BSW-SCHEDULABLE-ENTITY")
-        assert(runnable_mapping.bsw_entity_ref.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/BswM_MainFunction")
-        assert(runnable_mapping.swc_runnable_ref.dest == "RUNNABLE-ENTITY")
-        assert(runnable_mapping.swc_runnable_ref.value == "/AUTOSAR_BswM/SwComponentTypes/BswM/BswMInternalBehavior/RES_MainFunction")
+        assert(runnable_mapping.bswEntityRef.dest == "BSW-SCHEDULABLE-ENTITY")
+        assert(runnable_mapping.bswEntityRef.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/BswM_MainFunction")
+        assert(runnable_mapping.swcRunnableRef.dest == "RUNNABLE-ENTITY")
+        assert(runnable_mapping.swcRunnableRef.value == "/AUTOSAR_BswM/SwComponentTypes/BswM/BswMInternalBehavior/RES_MainFunction")
 
     def test_bsw_module_implementation(self):
         document = AUTOSAR.getInstance()
@@ -133,36 +145,48 @@ class TestBswMD:
         assert(len(code_desc.getArtifactDescriptors("SWHDR")) == 15)
         assert(len(code_desc.getArtifactDescriptors("SWMAKE")) == 2)
 
-        artifact_descs = sorted(code_desc.getArtifactDescriptors("SWMAKE"), key= lambda o: o.short_label)
-        assert(artifact_descs[0].short_label == "make::BswM_defs.mak")
-        assert(artifact_descs[0].category == "SWMAKE")
-        assert(artifact_descs[1].short_label == "make::BswM_rules.mak")
-        assert(artifact_descs[1].category == "SWMAKE")
+        artifact_descs = sorted(code_desc.getArtifactDescriptors("SWMAKE"), key = lambda o: o.getShortLabel().getValue())
+        assert(artifact_descs[0].getShortLabel().getValue() == "make::BswM_defs.mak")
+        assert(artifact_descs[0].getCategory().getValue() == "SWMAKE")
+        assert(artifact_descs[1].getShortLabel().getValue() == "make::BswM_rules.mak")
+        assert(artifact_descs[1].getCategory().getValue() == "SWMAKE")
 
-        assert(impl.programming_language == "C")
+        assert(impl.programming_language.getValue() == "C")
 
-        assert(impl.resource_consumption.short_name == "ResourceConsumption")
-        assert(len(impl.resource_consumption.getMemorySections()) == 8)
+        assert(impl._resource_consumption.short_name == "ResourceConsumption")
+        assert(len(impl._resource_consumption.getMemorySections()) == 8)
 
-        section = impl.resource_consumption.getMemorySection("CODE")
+        section = impl._resource_consumption.getMemorySection("CODE")
         assert(section.short_name == "CODE")
         assert(section.alignment == None)
-        assert(section.sw_addr_method_ref.dest == "SW-ADDR-METHOD")
-        assert(section.sw_addr_method_ref.value == "/AUTOSAR_MemMap/SwAddrMethods/CODE")
+        assert(section.swAddrMethodRef.dest == "SW-ADDR-METHOD")
+        assert(section.swAddrMethodRef.value == "/AUTOSAR_MemMap/SwAddrMethods/CODE")
 
-        section = impl.resource_consumption.getMemorySection("VAR_NO_INIT_UNSPECIFIED")
+        section = impl._resource_consumption.getMemorySection("VAR_NO_INIT_UNSPECIFIED")
         assert(section.short_name == "VAR_NO_INIT_UNSPECIFIED")
-        assert(section.alignment == "UNSPECIFIED")
-        assert(section.sw_addr_method_ref.dest == "SW-ADDR-METHOD")
-        assert(section.sw_addr_method_ref.value == "/AUTOSAR_MemMap/SwAddrMethods/VAR_NOINIT")
+        assert(section.alignment.getText() == "UNSPECIFIED")
+        assert(section.swAddrMethodRef.dest == "SW-ADDR-METHOD")
+        assert(section.swAddrMethodRef.value == "/AUTOSAR_MemMap/SwAddrMethods/VAR_NOINIT")
 
-        assert(impl.vendor_id == 1)
-        assert(impl.sw_version == "1.14.1")
+        assert(impl.vendor_id.getValue() == 1)
+        assert(impl.sw_version.getValue() == "1.14.1")
         assert(impl.swc_bsw_mapping_ref.dest == "SWC-BSW-MAPPING")
         assert(impl.swc_bsw_mapping_ref.value == "/AUTOSAR_BswM/SwcBswMappings/SwcBswMapping_0")
-        assert(impl.ar_release_version == "4.0.3")
+        assert(impl.ar_release_version.getValue() == "4.0.3")
         assert(impl.behavior_ref.dest == "BSW-INTERNAL-BEHAVIOR")
         assert(impl.behavior_ref.value == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
 
+    
+    def test_load_save(self):
+        document = AUTOSAR.getInstance()
+        document.clear()
+        parser = ARXMLParser()
+        parser.load("src/armodel/tests/test_files/SoftwareComponents.arxml", document)
+
+        writer = ARXMLWriter()
+        writer.save("data/generated.arxml", document)
+
+        assert(filecmp.cmp("src/armodel/tests/test_files/SoftwareComponents.arxml", "data/generated.arxml", shallow = False) == True)
+    
 
 

armodel/tests/test_armodel/parser/test_sw_components.py

@@ -0,0 +1,93 @@
+import filecmp
+from ....models.sw_component import CompositionSwComponentType
+from ....writer.arxml_writer import ARXMLWriter
+from ....parser.arxml_parser import ARXMLParser
+from ....models.ar_package import AUTOSAR
+
+class TestSWComponents:
+    def setup_method(self):
+        document = AUTOSAR.getInstance()
+        document.clear()
+        parser = ARXMLParser()
+        parser.load("src/armodel/tests/test_files/SoftwareComponents.arxml", document)
+
+    def test_ar_packages(self):
+        document = AUTOSAR.getInstance()
+        root_pkgs = sorted(document.getARPackages(), key = lambda pkg: pkg.short_name)
+
+        assert(len(root_pkgs) == 1)
+        assert("DemoApplication" == root_pkgs[0].short_name)
+
+    def test_composition_sw_component_types(self):
+        document = AUTOSAR.getInstance()
+        sw_component = document.find("/DemoApplication/SwComponentTypes/TopLevelComposition")  
+        assert(sw_component.short_name == "TopLevelComposition")
+        assert(isinstance(sw_component, CompositionSwComponentType))
+        prototypes = sw_component.getPortPrototypes()
+        assert(len(prototypes) == 2)
+
+    def test_composition_sw_component_types_sw_connectors(self):
+        document = AUTOSAR.getInstance()
+        sw_component = document.find("/DemoApplication/SwComponentTypes/TopLevelComposition")  
+        assert(isinstance(sw_component, CompositionSwComponentType))
+        assert(len(sw_component.getSwConnectors()) == 6)
+        assert(len(sw_component.getAssemblySwConnectors()) == 3)
+        assert(len(sw_component.getDelegationSwConnectors()) == 3)
+
+        connector_name_list = set()
+        for sw_connector in sw_component.getAssemblySwConnectors():
+            connector_name_list.add(sw_connector.short_name)
+
+        assert(connector_name_list == set(['a6a18805580c94537a4c82f6c289a4d', 'ac681652833fb4b12b920adab33a73b', 'ac681652833fb4b12b920adab33a73c']))
+
+        sw_component.removeElement("a6a18805580c94537a4c82f6c289a4d")
+        assert(len(sw_component.getAssemblySwConnectors()) == 2)
+
+        # remove all the AssemblySwConnector
+        sw_component.removeAllAssemblySwConnector()
+        assert(len(sw_component.getAssemblySwConnectors()) == 0)
+        assert(len(sw_component.getDelegationSwConnectors()) == 3)
+        
+        # remove all the DelegationSwConnector
+        sw_component.removeAllDelegationSwConnector()
+        assert(len(sw_component.getAssemblySwConnectors()) == 0)
+        assert(len(sw_component.getDelegationSwConnectors()) == 0)
+        
+    def test_software_components_arxml_loading_and_saving(self):
+        document = AUTOSAR.getInstance()
+        document.clear()
+        parser = ARXMLParser()
+        parser.load("src/armodel/tests/test_files/SoftwareComponents.arxml", document)
+
+        writer = ARXMLWriter()
+        writer.save("data/generated.arxml", document)
+
+        assert(filecmp.cmp("src/armodel/tests/test_files/SoftwareComponents.arxml", "data/generated.arxml", shallow = False) == True)
+
+    def test_software_components_arxml_loading_and_saving(self):
+        document = AUTOSAR.getInstance()
+        document.clear()
+        parser = ARXMLParser()
+        parser.load("src/armodel/tests/test_files/AUTOSAR_Datatypes.arxml", document)
+
+        writer = ARXMLWriter()
+        writer.save("data/generated_AUTOSAR_Datatypes.arxml", document)
+
+        assert(filecmp.cmp("src/armodel/tests/test_files/AUTOSAR_Datatypes.arxml", "data/generated_AUTOSAR_Datatypes.arxml", shallow = False) == True)
+
+    def test_bswm_bswmd_arxml_loading_and_saving(self):
+        document = AUTOSAR.getInstance()
+        document.clear()
+        parser = ARXMLParser()
+        parser.load("src/armodel/tests/test_files/BswM_Bswmd.arxml", document)
+
+        writer = ARXMLWriter()
+        writer.save("data/generated_BswM_Bswmd.arxml", document)
+
+        assert(filecmp.cmp("src/armodel/tests/test_files/BswM_Bswmd.arxml", "data/generated_BswM_Bswmd.arxml", shallow = False) == True)
+
+        
+
+    
+        
+        

armodel/writer/abstract_arxml_writer.py

@@ -0,0 +1,123 @@
+from abc import ABCMeta
+import re
+from xml.dom import minidom
+from colorama import Fore
+
+import logging
+import xml.etree.cElementTree as ET
+
+from armodel.models.ar_ref import TRefType
+
+from ..models.ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical, ARObject
+
+class AbstractARXMLWriter:
+    __metaclass__ = ABCMeta
+     
+    def __init__(self, options = None) -> None:
+        if type(self) == AbstractARXMLWriter:
+            raise NotImplementedError("AbstractARXMLWriter is an abstract class.")
+        
+        self.options = {}
+        self.options['warning'] = False
+        self.options['version'] = "4.2.2"
+        self.logger = logging.getLogger()
+        
+        self._processOptions(options=options)
+
+        self.nsmap = {
+            "xmlns": "http://autosar.org/schema/r4.0", 
+        }
+
+    def _processOptions(self, options):
+        if options:
+            if 'warning' in options:
+                self.options['warning'] = options['warning']
+
+    def _raiseError(self, error_msg):
+        if (self.options['warning'] == True):
+            self.logger.error(Fore.RED + error_msg + Fore.WHITE)
+        else:
+            raise ValueError(error_msg)
+        
+    def setARObjectAttributes(self, element: ET.Element, ar_obj: ARObject):
+        if ar_obj.timestamp is not None:
+            self.logger.debug("Timestamp: %s" % ar_obj.timestamp)
+            element.attrib['T'] = ar_obj.timestamp
+        if ar_obj.uuid is not None:
+            self.logger.debug("UUID: %s" % ar_obj.uuid)
+            element.attrib['UUID'] = ar_obj.uuid
+
+    '''
+    def setChildElementOptionalValue(self, element: ET.Element, key: str, value: str):
+        if value is not None:
+            child_element = ET.SubElement(element, key)
+            child_element.text = value
+    '''
+
+    '''
+    def setChildElementOptionalNumberValue(self, element: ET.Element, key: str, value: str):
+        if value is not None:
+            child_element = ET.SubElement(element, key)
+            child_element.text = str(value)
+    '''
+
+    def setChildElementOptionalNumericalValue(self, element: ET.Element, key: str, numerical: ARNumerical):
+        if numerical is not None:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, numerical)
+            child_element.text = numerical._text
+
+    def setChildElementOptionalLiteral(self, element: ET.Element, key: str, literal: ARLiteral):
+        if literal is not None:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, literal)
+            if literal._value is not None:
+                child_element.text = str(literal._value)
+
+    def setChildElementOptionalRefType(self, parent: ET.Element, child_tag_name: str, ref: TRefType):
+        if ref is not None:
+            child_tag = ET.SubElement(parent, child_tag_name)
+            if ref.dest is not None:
+                child_tag.attrib['DEST'] = ref.dest
+            if ref.value is not None:
+                child_tag.text = ref.value
+
+    def setChildElementOptionalFloatValue(self, element: ET.Element, key: str, value: ARFloat):
+        if value is not None:
+            child_element = ET.SubElement(element, key)
+            child_element.text = value.getText()
+
+    def setChildElementOptionalBooleanValue(self, element: ET.Element, key: str, value: ARBoolean) -> ET.Element:
+        child_element = None
+        if value is not None:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, value)
+            child_element.text = value.getText()
+        return element
+
+    def setChildElementOptionalLiteral(self, element: ET.Element, key: str, value: ARLiteral) -> ET.Element:
+        child_element = None
+        if value is not None:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, value)
+            child_element.text = value.getText()
+        return element      
+        
+    def patch_xml(self, xml: str) -> str:
+        #xml = xml.replace("<SW-DATA-DEF-PROPS-CONDITIONAL/>","<SW-DATA-DEF-PROPS-CONDITIONAL></SW-DATA-DEF-PROPS-CONDITIONAL>")
+        xml = re.sub(r"\<([\w-]+)\/\>",r"<\1></\1>", xml)
+        xml = re.sub(r"<((\w+)\s+\w+=\"\w+\")\/>", r"<\1></\2>", xml)
+        #xml = xml.replace("<USES-END-TO-END-PROTECTION>false</USES-END-TO-END-PROTECTION>", "<USES-END-TO-END-PROTECTION>0</USES-END-TO-END-PROTECTION>")
+        return xml
+
+    def saveToFile(self, filename, root: ET.Element):
+        xml = ET.tostring(root, encoding = "UTF-8", xml_declaration = True, short_empty_elements = False)
+        
+        dom = minidom.parseString(xml.decode())
+        xml = dom.toprettyxml(indent = "  ", encoding = "UTF-8")
+
+        text = self.patch_xml(xml.decode())
+    
+        with open(filename, "w", encoding="utf-8") as f_out:
+            #f_out.write(xml.decode())
+            f_out.write(text)