armodel 1.7.6__py3-none-any.whl → 1.7.8__py3-none-any.whl

armodel/parser/file_parser.py

@@ -3,6 +3,8 @@ import os
 import re
 from typing import List
 
+from colorama import Fore
+
 
 class FileListParser:
     '''
@@ -22,8 +24,8 @@ class FileListParser:
                 for line in f_in:
                     if not line.startswith('#'):
                         self.file_list.append(line.strip())
-        except:
-            self.logger.error("No such file or directory: %s" % os.path.realpath(file))
+        except IOError:
+            self.logger.error(Fore.RED + "No such file or directory: %s" % os.path.realpath(file) + Fore.WHITE)
 
     def parse_dir_files(self, dir_name):
         for (root, _, files) in os.walk(dir_name, topdown=False):
@@ -41,4 +43,4 @@ class FileListParser:
                     logging.debug("Parse ARXML list file %s " % input_file)
                     self.parse_text_file(input_file[1:])
                 else:
-                    self.file_list.append(input_file)
+                    self.file_list.append(input_file)

armodel/tests/test_armodel/models/test_ar_package.py

@@ -2,17 +2,11 @@
 import pytest
 
 from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationPrimitiveDataType, ApplicationRecordDataType
-
 from ....models.M2.MSR.AsamHdo.BaseTypes import SwBaseType
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import PackageableElement
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable, Referrable
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-
 from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ApplicationSwComponentType, AtomicSwComponentType, EcuAbstractionSwComponentType, SwComponentType
 from ....models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
@@ -23,28 +17,29 @@ from ....models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import Cli
 from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ServiceSwComponentType
 from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Components import CompositionSwComponentType
 
+
 class TestAUTOSAR:
 
     def test_autosar_singleton_exception(self):
         AUTOSAR.getInstance()
         with pytest.raises(Exception) as err:
             AUTOSAR()
-        assert(str(err.value) == "The AUTOSAR is singleton!")
+        assert (str(err.value) == "The AUTOSAR is singleton!")
 
     def test_cannot_find_element(self):
         document = AUTOSAR.getInstance()
-        #with pytest.raises(Exception) as err:
+        # with pytest.raises(Exception) as err:
         #    document.find("/sw_package/not_found")
-        #assert(str(err.value) ==
+        # assert(str(err.value) ==
         #       "The sw_package of reference </sw_package/not_found> does not exist.")
-        assert(document.find("/sw_package/not_found") == None)
+        assert (document.find("/sw_package/not_found") is None)
 
     def test_autosar(self):
         document = AUTOSAR.getInstance()
         assert (isinstance(document, CollectableElement))
         assert (isinstance(document, AUTOSAR))
         assert (len(document.getARPackages()) == 0)
-        assert (document.schema_location == "")
+        assert (document.schema_location is None)
         assert (document.full_name == "")
 
     def test_create_autosar_package(self):

armodel/tests/test_armodel/models/test_bsw_module_template.py

@@ -1,10 +1,9 @@
 import pytest
 
 from ....models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
-
 from ....models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswModuleEntity
-
 from ....models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
+from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import CategoryString
 from .... import AUTOSAR
 
 class TestBswModuleDescription:
@@ -24,7 +23,10 @@ class TestBswModuleDescription:
         #assert(str(err.value) == "Invalid category <invalid> of BswModuleDescription <bsw_module>")
 
         bsw_module_description.setCategory("BSW_MODULE")
-        assert(bsw_module_description.getCategory() == "BSW_MODULE")
+        assert(bsw_module_description.getCategory().getValue() == "BSW_MODULE")
+
+        bsw_module_description.setCategory(CategoryString().setValue("BSW_MODULE"))
+        assert(bsw_module_description.getCategory().getValue() == "BSW_MODULE")
 
 class Test_M2_AUTOSARTemplates_BswModuleTemplate_BswInterfaces:
     def test_BswModuleEntry(self):

armodel/tests/test_armodel/models/test_datatype.py

@@ -144,7 +144,7 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
 
         assert(data_type.parent == ar_root)
         assert(data_type.short_name == "ApplicationArrayDataType")
-        assert(data_type.dynamic_array_size_profile == None)
+        assert(data_type.dynamicArraySizeProfile == None)
         assert(data_type.element == None)
 
     def test_ApplicationRecordDataType(self):

armodel/tests/test_armodel/models/test_port_interface.py

@@ -23,186 +23,185 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_PortInterface:
     def test_PortInterface(self):
         with pytest.raises(NotImplementedError) as err:
             PortInterface(AUTOSAR.getInstance(), "PortInterface")
-        assert(str(err.value) == "PortInterface is an abstract class.")
+        assert (str(err.value) == "PortInterface is an abstract class.")
 
     def test_DataInterface(self):
         with pytest.raises(NotImplementedError) as err:
             DataInterface(AUTOSAR.getInstance(), "DataInterface")
-        assert(str(err.value) == "DataInterface is an abstract class.")
+        assert (str(err.value) == "DataInterface is an abstract class.")
 
     def test_NvDataInterface(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         data_if = NvDataInterface(ar_root, "NvDataInterface")
 
-        assert(isinstance(data_if, ARElement))
-        assert(isinstance(data_if, ARObject))
-        # assert(isinstance(sr, AtpBlueprint))
-        # assert(isinstance(sr, AtpBlueprintable))
-        # assert(isinstance(sr, AtpClassifier))
-        assert(isinstance(data_if, AtpType))
-        assert(isinstance(data_if, CollectableElement))
-        assert(isinstance(data_if, DataInterface))
-        assert(isinstance(data_if, Identifiable))
-        assert(isinstance(data_if, MultilanguageReferrable))
-        assert(isinstance(data_if, PackageableElement))
-        assert(isinstance(data_if, PortInterface))
-        assert(isinstance(data_if, Referrable))
-        assert(isinstance(data_if, NvDataInterface))
-
-        assert(data_if.parent == ar_root)
-        assert(data_if.short_name == "NvDataInterface")
+        assert (isinstance(data_if, ARElement))
+        assert (isinstance(data_if, ARObject))
+        # assert (isinstance(sr, AtpBlueprint))
+        # assert (isinstance(sr, AtpBlueprintable))
+        # assert (isinstance(sr, AtpClassifier))
+        assert (isinstance(data_if, AtpType))
+        assert (isinstance(data_if, CollectableElement))
+        assert (isinstance(data_if, DataInterface))
+        assert (isinstance(data_if, Identifiable))
+        assert (isinstance(data_if, MultilanguageReferrable))
+        assert (isinstance(data_if, PackageableElement))
+        assert (isinstance(data_if, PortInterface))
+        assert (isinstance(data_if, Referrable))
+        assert (isinstance(data_if, NvDataInterface))
+
+        assert (data_if.parent == ar_root)
+        assert (data_if.short_name == "NvDataInterface")
 
     def test_ParameterInterface(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         data_if = ParameterInterface(ar_root, "ParameterInterface")
 
-        assert(isinstance(data_if, ARElement))
-        assert(isinstance(data_if, ARObject))
-        # assert(isinstance(sr, AtpBlueprint))
-        # assert(isinstance(sr, AtpBlueprintable))
-        # assert(isinstance(sr, AtpClassifier))
-        assert(isinstance(data_if, AtpType))
-        assert(isinstance(data_if, CollectableElement))
-        assert(isinstance(data_if, DataInterface))
-        assert(isinstance(data_if, Identifiable))
-        assert(isinstance(data_if, MultilanguageReferrable))
-        assert(isinstance(data_if, PackageableElement))
-        assert(isinstance(data_if, PortInterface))
-        assert(isinstance(data_if, Referrable))
-        assert(isinstance(data_if, ParameterInterface))
-
-        assert(data_if.parent == ar_root)
-        assert(data_if.short_name == "ParameterInterface")
+        assert (isinstance(data_if, ARElement))
+        assert (isinstance(data_if, ARObject))
+        # assert (isinstance(sr, AtpBlueprint))
+        # assert (isinstance(sr, AtpBlueprintable))
+        # assert (isinstance(sr, AtpClassifier))
+        assert (isinstance(data_if, AtpType))
+        assert (isinstance(data_if, CollectableElement))
+        assert (isinstance(data_if, DataInterface))
+        assert (isinstance(data_if, Identifiable))
+        assert (isinstance(data_if, MultilanguageReferrable))
+        assert (isinstance(data_if, PackageableElement))
+        assert (isinstance(data_if, PortInterface))
+        assert (isinstance(data_if, Referrable))
+        assert (isinstance(data_if, ParameterInterface))
+
+        assert (data_if.parent == ar_root)
+        assert (data_if.short_name == "ParameterInterface")
 
     def test_SenderReceiverInterface(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         sr_if = SenderReceiverInterface(ar_root, "sr_if")
 
-        assert(isinstance(sr_if, ARElement))
-        assert(isinstance(sr_if, ARObject))
-        # assert(isinstance(sr, AtpBlueprint))
-        # assert(isinstance(sr, AtpBlueprintable))
-        # assert(isinstance(sr, AtpClassifier))
-        assert(isinstance(sr_if, AtpType))
-        assert(isinstance(sr_if, CollectableElement))
-        assert(isinstance(sr_if, DataInterface))
-        assert(isinstance(sr_if, Identifiable))
-        assert(isinstance(sr_if, MultilanguageReferrable))
-        assert(isinstance(sr_if, PackageableElement))
-        assert(isinstance(sr_if, PortInterface))
-        assert(isinstance(sr_if, Referrable))
-        assert(isinstance(sr_if, SenderReceiverInterface))
-
-        assert(sr_if.short_name == "sr_if")
-        assert(sr_if.parent == ar_root)
-        assert(len(sr_if.getDataElements()) == 0)
+        assert (isinstance(sr_if, ARElement))
+        assert (isinstance(sr_if, ARObject))
+        # assert (isinstance(sr, AtpBlueprint))
+        # assert (isinstance(sr, AtpBlueprintable))
+        # assert (isinstance(sr, AtpClassifier))
+        assert (isinstance(sr_if, AtpType))
+        assert (isinstance(sr_if, CollectableElement))
+        assert (isinstance(sr_if, DataInterface))
+        assert (isinstance(sr_if, Identifiable))
+        assert (isinstance(sr_if, MultilanguageReferrable))
+        assert (isinstance(sr_if, PackageableElement))
+        assert (isinstance(sr_if, PortInterface))
+        assert (isinstance(sr_if, Referrable))
+        assert (isinstance(sr_if, SenderReceiverInterface))
+
+        assert (sr_if.short_name == "sr_if")
+        assert (sr_if.parent == ar_root)
+        assert (len(sr_if.getDataElements()) == 0)
 
         element = sr_if.createDataElement("element")
-        assert(isinstance(element, VariableDataPrototype))
-        assert(element.short_name == "element")
-        assert(len(sr_if.getDataElements()) == 1)
+        assert (isinstance(element, VariableDataPrototype))
+        assert (element.short_name == "element")
+        assert (len(sr_if.getDataElements()) == 1)
 
         element2 = sr_if.getDataElement("element")
-        assert(element == element2)
+        assert (element == element2)
 
         with pytest.raises(IndexError) as err:
             sr_if.getDataElement("non_exist_element")
-        assert(str(err.value) == "data element <non_exist_element> can not be found.")
+        assert (str(err.value) == "data element <non_exist_element> can not be found.")
 
     def test_ArgumentDataPrototype(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         prototype = ArgumentDataPrototype(ar_root, "ArgumentDataPrototype")
 
-        assert(isinstance(prototype, ARObject))
-        assert(isinstance(prototype, AtpFeature))
-        assert(isinstance(prototype, AtpPrototype))
-        assert(isinstance(prototype, AutosarDataPrototype))
-        assert(isinstance(prototype, DataPrototype))
-        assert(isinstance(prototype, Identifiable))
-        assert(isinstance(prototype, MultilanguageReferrable))
-        assert(isinstance(prototype, Referrable))
-        assert(isinstance(prototype, ArgumentDataPrototype))
-
-        assert(prototype.getParent() == ar_root)
-        assert(prototype.getShortName() == "ArgumentDataPrototype")
-        assert(prototype.getDirection() == None)
-        assert(prototype.getServerArgumentImplPolicy() == None)
+        assert (isinstance(prototype, ARObject))
+        assert (isinstance(prototype, AtpFeature))
+        assert (isinstance(prototype, AtpPrototype))
+        assert (isinstance(prototype, AutosarDataPrototype))
+        assert (isinstance(prototype, DataPrototype))
+        assert (isinstance(prototype, Identifiable))
+        assert (isinstance(prototype, MultilanguageReferrable))
+        assert (isinstance(prototype, Referrable))
+        assert (isinstance(prototype, ArgumentDataPrototype))
+
+        assert (prototype.getParent() == ar_root)
+        assert (prototype.getShortName() == "ArgumentDataPrototype")
+        assert (prototype.getDirection() == None)
+        assert (prototype.getServerArgumentImplPolicy() == None)
 
     def test_ApplicationError(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         app_error = ApplicationError(ar_root, "ApplicationError")
 
-        assert(isinstance(app_error, ARObject))
-        assert(isinstance(app_error, Identifiable))
-        assert(isinstance(app_error, MultilanguageReferrable))
-        assert(isinstance(app_error, Referrable))
-        assert(isinstance(app_error, ApplicationError))
+        assert (isinstance(app_error, ARObject))
+        assert (isinstance(app_error, Identifiable))
+        assert (isinstance(app_error, MultilanguageReferrable))
+        assert (isinstance(app_error, Referrable))
+        assert (isinstance(app_error, ApplicationError))
 
-        assert(app_error.parent == ar_root)
-        assert(app_error.short_name == "ApplicationError")
+        assert (app_error.parent == ar_root)
+        assert (app_error.short_name == "ApplicationError")
 
     def test_ClientServerOperation(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         operation = ClientServerOperation(ar_root, "client_server_operation")
-        assert(isinstance(operation, ARObject))
-        # assert(isinstance(operation, AtpClassifier))
-        assert(isinstance(operation, AtpFeature))
-        assert(isinstance(operation, Identifiable))
-        assert(isinstance(operation, MultilanguageReferrable))
-        assert(isinstance(operation, Referrable))
-        assert(isinstance(operation, ClientServerOperation))
-        assert(operation.short_name == "client_server_operation")
-
-        prototype = ArgumentDataPrototype(ar_root, "argument_data_prototype1")
-        operation.addArgumentDataPrototype(prototype)
-        assert(prototype.short_name == "argument_data_prototype1")
-
-        assert(len(operation.getArgumentDataPrototypes()) == 1)
-        assert(operation.getArgumentDataPrototypes()[0] == prototype)
+        assert (isinstance(operation, ARObject))
+        # assert (isinstance(operation, AtpClassifier))
+        assert (isinstance(operation, AtpFeature))
+        assert (isinstance(operation, Identifiable))
+        assert (isinstance(operation, MultilanguageReferrable))
+        assert (isinstance(operation, Referrable))
+        assert (isinstance(operation, ClientServerOperation))
+        assert (operation.short_name == "client_server_operation")
+
+        prototype = operation.createArgumentDataPrototype("argument_data_prototype1")
+        assert (prototype.short_name == "argument_data_prototype1")
+
+        assert (len(operation.getArguments()) == 1)
+        assert (operation.getArguments()[0] == prototype)
 
         refType = RefType()
         refType.dest = "APPLICATION-ERROR"
         refType.value = "/AUTOSAR_NvM/PortInterfaces/NvMService/E_NOT_OK"
         operation.addPossibleErrorRef(refType)
 
-        assert(len(operation.getPossbileErrorRefs()) == 1)
-        assert(operation.getPossbileErrorRefs()[0] == refType)
+        assert (len(operation.getPossibleErrorRefs()) == 1)
+        assert (operation.getPossibleErrorRefs()[0] == refType)
 
     def test_ClientServerInterface(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         cs_if = ClientServerInterface(ar_root, "client_server_interface")
-        assert(isinstance(cs_if, ARObject))
-        assert(isinstance(cs_if, ARElement))
-        # assert(isinstance(operation, AtpBlueprint))
-        # assert(isinstance(operation, AtpBlueprintable))
-        # assert(isinstance(operation, AtpClassifier))
-        assert(isinstance(cs_if, AtpType))
-        assert(isinstance(cs_if, CollectableElement))
-        assert(isinstance(cs_if, Identifiable))
-        assert(isinstance(cs_if, MultilanguageReferrable))
-        assert(isinstance(cs_if, PackageableElement))
-        assert(isinstance(cs_if, PortInterface))
-        assert(isinstance(cs_if, Referrable))
+        assert (isinstance(cs_if, ARObject))
+        assert (isinstance(cs_if, ARElement))
+        # assert (isinstance(operation, AtpBlueprint))
+        # assert (isinstance(operation, AtpBlueprintable))
+        # assert (isinstance(operation, AtpClassifier))
+        assert (isinstance(cs_if, AtpType))
+        assert (isinstance(cs_if, CollectableElement))
+        assert (isinstance(cs_if, Identifiable))
+        assert (isinstance(cs_if, MultilanguageReferrable))
+        assert (isinstance(cs_if, PackageableElement))
+        assert (isinstance(cs_if, PortInterface))
+        assert (isinstance(cs_if, Referrable))
 
         element = cs_if.createOperation("operation")
-        assert(isinstance(element, ClientServerOperation))
-        assert(element.short_name == "operation")
-        assert(len(cs_if.getOperations()) == 1)
+        assert (isinstance(element, ClientServerOperation))
+        assert (element.short_name == "operation")
+        assert (len(cs_if.getOperations()) == 1)
 
         element2 = cs_if.getOperations()[0]
-        assert(element == element2)
+        assert (element == element2)
 
         element = cs_if.createApplicationError("error")
-        assert(isinstance(element, ApplicationError))
-        assert(element.short_name == "error")
-        assert(len(cs_if.getPossibleErrors()) == 1)
+        assert (isinstance(element, ApplicationError))
+        assert (element.short_name == "error")
+        assert (len(cs_if.getPossibleErrors()) == 1)
 
         element2 = cs_if.getPossibleErrors()[0]
-        assert(element == element2)
+        assert (element == element2)

armodel/tests/test_armodel/parser/test_bsw_module_descriiption.py

@@ -0,0 +1,218 @@
+import filecmp
+from typing import List
+
+from ....models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior
+from ....models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
+from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
+from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
+
+from .... import AUTOSAR
+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].getShortName() == "AUTOSAR_BswM")
+        assert (root_pkgs[1].getShortName() == "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.getShortName() == "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.getShortName() == "BswM")
+        assert (bsw_module_desc.moduleId.getText() == "34")
+        assert (bsw_module_desc.moduleId.getValue() == 34)
+
+        # verify the provided entries
+        assert (len(bsw_module_desc.implementedEntryRefs) == 2)
+        assert (bsw_module_desc.implementedEntryRefs[0].getDest() == "BSW-MODULE-ENTRY")
+        assert (bsw_module_desc.implementedEntryRefs[0].getValue() == "/AUTOSAR_BswM/BswModuleEntrys/BswM_Init")
+        assert (bsw_module_desc.implementedEntryRefs[1].getDest() == "BSW-MODULE-ENTRY")
+        assert (bsw_module_desc.implementedEntryRefs[1].getValue() == "/AUTOSAR_BswM/BswModuleEntrys/BswM_MainFunction")
+
+        assert (len(bsw_module_desc.getInternalBehaviors()) == 1)
+        behavior = bsw_module_desc.getInternalBehaviors()[0]
+        assert (behavior.short_name == "InternalBehavior_0")
+
+        assert (len(behavior.getDataTypeMappingRefs()) == 1)
+        data_type_mapping_ref = behavior.getDataTypeMappingRefs()[0]
+        assert (data_type_mapping_ref.getDest() == "DATA-TYPE-MAPPING-SET")
+        assert (data_type_mapping_ref.getValue() == "/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.minimumStartInterval is not None)
+        assert (entity.minimumStartIntervalMs is not None)
+        assert (len(entity.getCanEnterExclusiveAreaRefs()) == 1)
+        assert (entity.getCanEnterExclusiveAreaRefs()[0].getDest() == "EXCLUSIVE-AREA")
+        assert (entity.getCanEnterExclusiveAreaRefs()[0].getValue() == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/SCHM_BSWM_EXCLUSIVE_AREA")      # noqa E501
+        assert (entity.implementedEntryRef.getDest() == "BSW-MODULE-ENTRY")
+        assert (entity.implementedEntryRef.getValue() == "/AUTOSAR_BswM/BswModuleEntrys/BswM_MainFunction")
+
+        assert (len(behavior.getBswTimingEvents()) == 1)
+        event = behavior.getBswTimingEvents()[0]
+        assert (event.short_name == "TimingEvent_MainFunction")
+        assert (event.startsOnEventRef.getDest() == "BSW-SCHEDULABLE-ENTITY")
+        assert (event.startsOnEventRef.getValue() == "/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].getShortName() == "BswM_Init")
+        assert (entries[0].getServiceId().getValue() == 0)
+        assert (entries[0].getIsReentrant().getValue() is False)
+        assert (entries[0].getIsSynchronous().getValue() is True)
+        assert (entries[0].getCallType().getText() == "REGULAR")
+        assert (entries[0].getExecutionContext().getText() == "UNSPECIFIED")
+        assert (entries[0].getSwServiceImplPolicy().getText() == "STANDARD")
+
+        assert (entries[1].getShortName() == "BswM_MainFunction")
+        assert (entries[1].getServiceId().getValue() == 3)
+        assert (entries[1].getIsReentrant().getValue() is False)
+        assert (entries[1].getIsSynchronous().getValue() is True)
+        assert (entries[1].getCallType().getText() == "SCHEDULED")
+        assert (entries[1].getExecutionContext().getText() == "TASK")
+        assert (entries[1].getSwServiceImplPolicy().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.getDest() == "BSW-INTERNAL-BEHAVIOR")
+        assert (mappings[0].bswBehaviorRef.getValue() == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
+        
+        assert (len(mappings[0].getRunnableMappings()) == 1)
+        runnable_mapping = mappings[0].getRunnableMappings()[0]
+        assert (runnable_mapping.getBswEntityRef().getDest() == "BSW-SCHEDULABLE-ENTITY")
+        assert (runnable_mapping.getBswEntityRef().getValue() == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0/BswM_MainFunction")
+        assert (runnable_mapping.getSwcRunnableRef().getDest() == "RUNNABLE-ENTITY")
+        assert (runnable_mapping.getSwcRunnableRef().getValue() == "/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())       # type: List[AutosarEngineeringObject]    # noqa E501
+        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.programmingLanguage.getValue() == "C")
+
+        assert (impl.resourceConsumption.short_name == "ResourceConsumption")
+        assert (len(impl.resourceConsumption.getMemorySections()) == 8)
+
+        section = impl.resourceConsumption.getMemorySection("CODE")
+        assert (section.short_name == "CODE")
+        assert (section.alignment is None)
+        assert (section.swAddrMethodRef.getDest() == "SW-ADDR-METHOD")
+        assert (section.swAddrMethodRef.getValue() == "/AUTOSAR_MemMap/SwAddrMethods/CODE")
+
+        section = impl.resourceConsumption.getMemorySection("VAR_NO_INIT_UNSPECIFIED")
+        assert (section.short_name == "VAR_NO_INIT_UNSPECIFIED")
+        assert (section.alignment.getText() == "UNSPECIFIED")
+        assert (section.swAddrMethodRef.getDest() == "SW-ADDR-METHOD")
+        assert (section.swAddrMethodRef.getValue() == "/AUTOSAR_MemMap/SwAddrMethods/VAR_NOINIT")
+
+        assert (impl.vendorId.getValue() == 1)
+        assert (impl.swVersion.getValue() == "1.14.1")
+        assert (impl.swcBswMappingRef.getDest() == "SWC-BSW-MAPPING")
+        assert (impl.swcBswMappingRef.getValue() == "/AUTOSAR_BswM/SwcBswMappings/SwcBswMapping_0")
+        assert (impl.arReleaseVersion.getValue() == "4.0.3")
+        assert (impl.behaviorRef.getDest() == "BSW-INTERNAL-BEHAVIOR")
+        assert (impl.behaviorRef.getValue() == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
+
+    def test_get_implementation(self):
+        document = AUTOSAR.getInstance()
+        impl = document.getImplementation("/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
+        assert (impl.getFullName() == "/EB_BswM_TxDxM1I14R0/Implementations/BswImplementation_0")
+        assert (isinstance(impl, BswImplementation))
+
+    def test_get_behavior(self):
+        document = AUTOSAR.getInstance()
+        behavior = document.getBehavior("/EB_BswM_TxDxM1I14R0/Implementations/BswImplementation_0")
+        assert (behavior.getFullName() == "/AUTOSAR_BswM/BswModuleDescriptions/BswM/InternalBehavior_0")
+        assert (isinstance(behavior, BswInternalBehavior))
+
+    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) is 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) is True)