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

armodel/tests/test_armodel/parser/test_parse_bswmd.py

@@ -0,0 +1,192 @@
+import filecmp
+
+from .... import AUTOSAR, ARPackage
+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()
+        parser = ARXMLParser()
+        parser.load("src/armodel/tests/test_files/BswM_Bswmd.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) == 2)
+        assert(root_pkgs[0].short_name == "AUTOSAR_BswM")
+        assert(root_pkgs[1].short_name == "EB_BswM_TxDxM1I14R0")
+
+        root_pkg_0_pkgs = sorted(root_pkgs[0].getARPackages(), key = lambda pkg: pkg.short_name)
+        assert(len(root_pkg_0_pkgs) == 3)
+
+        bsw_module_desc_pkg = root_pkg_0_pkgs[0]   # type：ARPackage  
+        assert(bsw_module_desc_pkg.short_name == "BswModuleDescriptions")
+
+        root_pkg_1_pkgs = root_pkgs[1].getARPackages()
+        assert(len(root_pkg_1_pkgs) == 1)
+
+    def test_bsw_module_description(self):
+        document = AUTOSAR.getInstance()
+
+        pkg = document.find("/AUTOSAR_BswM/BswModuleDescriptions")     # type: ARPackage
+        bsw_module_descs = pkg.getBswModuleDescriptions()
+        assert(len(bsw_module_descs) == 1)
+
+        bsw_module_desc = bsw_module_descs[0]
+        assert(bsw_module_desc.short_name == "BswM")
+        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._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]
+        assert(behavior.short_name == "InternalBehavior_0")
+
+        assert(len(behavior.getDataTypeMappingRefs()) == 1)
+        data_type_mapping_ref = behavior.getDataTypeMappingRefs()[0]
+        assert(data_type_mapping_ref.dest == "DATA-TYPE-MAPPING-SET")
+        assert(data_type_mapping_ref.value == "/BswMMode/DataTypeMappingSets/BswMModeMapping")
+
+        assert(len(behavior.getExclusiveAreas()) == 1)
+        assert(behavior.getExclusiveAreas()[0].short_name == "SCHM_BSWM_EXCLUSIVE_AREA")
+
+        assert(len(behavior.getBswSchedulableEntities()) == 1)
+        entity = behavior.getBswSchedulableEntities()[0]
+        assert(entity.short_name == "BswM_MainFunction")
+        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")
+        assert(entity.implemented_entry_ref.value == "/AUTOSAR_BswM/BswModuleEntrys/BswM_MainFunction")
+
+        assert(len(behavior.getBswTimingEvents()) == 1)
+        event = behavior.getBswTimingEvents()[0]
+        assert(event.short_name == "TimingEvent_MainFunction")
+        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()
+
+        pkg = document.find("/AUTOSAR_BswM/BswModuleEntrys")     # type: ARPackage
+        entries = sorted(pkg.getBswModuleEntries(), key= lambda entry: entry.short_name)
+        assert(len(entries) == 2)
+
+        assert(entries[0].short_name == "BswM_Init")
+        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.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._value == 3)
+        assert(entries[1].is_reentrant.value == False)
+        assert(entries[1].is_synchronous.value == True)
+        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()
+
+        pkg = document.find("/AUTOSAR_BswM/SwcBswMappings")     # type: ARPackage
+        mappings = pkg.getSwcBswMappings()
+        assert(len(mappings) == 1)
+
+        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.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()
+
+        pkg = document.find("/EB_BswM_TxDxM1I14R0/Implementations")     # type: ARPackage
+        assert(len(pkg.getBswImplementations()) == 1)
+        impl = pkg.getBswImplementations()[0]
+        assert(impl.short_name == "BswImplementation_0")
+        assert(len(impl.getCodeDescriptors()) == 1)
+        
+        code_desc = impl.getCodeDescriptors()[0]
+        assert(code_desc.short_name == "Files")
+        assert(len(code_desc.getArtifactDescriptors()) == 21)
+        assert(len(code_desc.getArtifactDescriptors("SWSRC")) == 4)
+        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.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.getValue() == "C")
+
+        assert(impl._resource_consumption.short_name == "ResourceConsumption")
+        assert(len(impl._resource_consumption.getMemorySections()) == 8)
+
+        section = impl._resource_consumption.getMemorySection("CODE")
+        assert(section.short_name == "CODE")
+        assert(section.alignment == None)
+        assert(section.swAddrMethodRef.dest == "SW-ADDR-METHOD")
+        assert(section.swAddrMethodRef.value == "/AUTOSAR_MemMap/SwAddrMethods/CODE")
+
+        section = impl._resource_consumption.getMemorySection("VAR_NO_INIT_UNSPECIFIED")
+        assert(section.short_name == "VAR_NO_INIT_UNSPECIFIED")
+        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.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.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/__init__.py

@@ -0,0 +1 @@
+from .arxml_writer import ARXMLWriter

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)