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

armodel/report/__init__.py

@@ -0,0 +1 @@
+from .connector_xls_report import ConnectorXlsReport

armodel/report/connector_xls_report.py

@@ -0,0 +1,76 @@
+from .excel_report import ExcelReporter
+from ..models import AUTOSAR, ARPackage, CompositionSwComponentType
+from ..models import PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
+from typing import List
+
+class ConnectorXlsReport(ExcelReporter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.swcs = []              # type: List[CompositionSwComponentType]
+
+    def _parse_pkg(self, parent: ARPackage):
+        for pkg in parent.getARPackages():
+            self._parse_pkg(pkg)
+        for swc in parent.getSwComponentTypes():
+            self.swcs.append(swc)
+
+    def import_data(self, document: AUTOSAR):
+        for pkg in document.getARPackages():
+            self._parse_pkg(pkg)
+
+    def _write_assembly_sw_connection(self, swc: CompositionSwComponentType, index = 0):
+        sheet = self.wb.create_sheet("%s - AC" % swc.short_name, index)
+        title_row = ["Short Name", "Provide SW-C", "PPort", "Request SW-C", "RPort"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for connector in swc.getAssemblySwConnectors():
+            self._logger.debug("Write AssemblySwConnection %s" % connector.short_name)
+            self.write_cell(sheet, row, 1, connector.short_name)
+            self.write_cell(sheet, row, 2, connector.provider_iref.context_component_ref.value)
+            self.write_cell(sheet, row, 3, connector.provider_iref.target_p_port_ref.value)
+            self.write_cell(sheet, row, 4, connector.requester_iref.context_component_ref.value)
+            self.write_cell(sheet, row, 5, connector.requester_iref.target_r_port_ref.value)
+            row += 1
+
+        self.auto_width(sheet)
+
+    def _write_delegation_sw_connection(self, swc: CompositionSwComponentType, index = 0):
+        sheet = self.wb.create_sheet("%s - DC" % swc.short_name, index)
+        title_row = ["Short Name", "Inner SW-C", "Inner PPort", "Outer PPort", "Inner RPort", "Outer RPort"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for connector in swc.getDelegationSwConnectors():
+            self._logger.debug("Write DelegationSwConnection %s" % connector.short_name)
+            self.write_cell(sheet, row, 1, connector.short_name)
+
+            if connector.inner_port_iref:
+                if isinstance(connector.inner_port_iref, PPortInCompositionInstanceRef):
+                    self.write_cell(sheet, row, 2, connector.inner_port_iref.context_component_ref.value)
+                    self.write_cell(sheet, row, 3, connector.inner_port_iref.target_p_port_ref.value)
+                elif isinstance(connector.inner_port_iref, RPortInCompositionInstanceRef):
+                    self.write_cell(sheet, row, 2, connector.inner_port_iref.context_component_ref.value)
+                    self.write_cell(sheet, row, 5, connector.inner_port_iref.target_r_port_ref.value)
+
+            if connector.outer_port_ref.dest == "P-PORT-PROTOTYPE":
+                self.write_cell(sheet, row, 4, connector.outer_port_ref.value)
+            elif connector.outer_port_ref.dest == "R-PORT-PROTOTYPE":
+                self.write_cell(sheet, row, 6, connector.outer_port_ref.value)
+            else:
+                raise ValueError("Invalid OUTER-PORT-REF of SwConnector <%s>" % connector.short_name)
+            row += 1
+
+        self.auto_width(sheet)
+
+    def write(self, filename: str):
+        swc_list = filter(lambda o: isinstance(o, CompositionSwComponentType), self.swcs)
+        
+        idx = 1
+        for swc in sorted(swc_list, key = lambda o: o.short_name):
+            self._logger.info("CompositionSwComponentType %s" % swc.short_name)
+            self._write_assembly_sw_connection(swc, idx)
+            self._write_delegation_sw_connection(swc, idx + 1)
+            idx += 2
+
+        self.wb.save(filename)

armodel/report/excel_report.py

@@ -0,0 +1,42 @@
+from openpyxl import Workbook
+
+import logging
+
+class ExcelReporter:
+    def __init__(self) -> None:
+        self.wb = Workbook()
+        self._logger = logging.getLogger()
+    
+    def write_revision(self):
+        sheet = self.wb['Sheet']
+        sheet.title = "History"
+
+        title_rows = ["When", "Who", "Version", "History"]
+        self.write_title_row(sheet, title_rows)
+
+    def auto_width(self, worksheet):
+        dims = {}
+        for row in worksheet.rows:
+            for cell in row:
+                if cell.value:
+                    dims[cell.column_letter] = max((dims.get(cell.column_letter, 0), len(str(cell.value))))
+
+        for col, value in dims.items():
+            worksheet.column_dimensions[col].width = (value + 2) + 2
+
+    def write_title_row(self, sheet, title_row):
+        for idx in range(0, len(title_row)):
+            cell = sheet.cell(row=1, column=idx + 1)
+            cell.value = title_row[idx]
+
+    def write_cell(self, sheet, row, column, value, format = None):
+        cell = sheet.cell(row = row, column=column) 
+        cell.value = value
+        if (format != None):
+            if ('alignment' in format):
+                cell.alignment = format['alignment']
+            if ('number_format' in format):
+                cell.number_format = format['number_format']
+
+    def save(self, name: str):
+        self.wb.save(name)

armodel/tests/test_armodel/models/test_ar_package.py

@@ -0,0 +1,294 @@
+""" Test AR Package """
+import pytest
+
+from ....models.ar_package import AUTOSAR
+from ....models.datatype import ApplicationPrimitiveDataType, ApplicationRecordDataType, DataTypeMappingSet, ImplementationDataType, SwBaseType
+from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, Referrable
+from ....models.m2_msr import CompuMethod
+from ....models.port_interface import ClientServerInterface, DataInterface, PortInterface, SenderReceiverInterface
+from ....models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, ServiceSwComponentType, SwComponentType
+
+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!")
+
+    def test_cannot_find_element(self):
+        document = AUTOSAR.getInstance()
+        #with pytest.raises(Exception) as err:
+        #    document.find("/sw_package/not_found")
+        #assert(str(err.value) ==
+        #       "The sw_package of reference </sw_package/not_found> does not exist.")
+        assert(document.find("/sw_package/not_found") == None)
+
+    def test_autosar(self):
+        document = AUTOSAR.getInstance()
+        assert (isinstance(document, CollectableElement))
+        assert (isinstance(document, AUTOSAR))
+        assert (len(document.getARPackages()) == 0)
+        assert (document.version == "4.3.0")
+        assert (document.full_name == "")
+
+    def test_create_autosar_package(self):
+        document = AUTOSAR.getInstance()
+        ar_package = document.createARPackage("sw_package")
+        assert ("sw_package" == ar_package.short_name)
+        assert (len(document.getARPackages()) == 1)
+        assert (document.getARPackages()[0] == ar_package)
+
+        ar_package = document.find("/sw_package")
+        assert ("sw_package" == ar_package.short_name)
+
+        assert(isinstance(ar_package, ARObject))
+        assert(isinstance(ar_package, Identifiable))
+        assert(isinstance(ar_package, Referrable))
+        assert(isinstance(ar_package, MultilanguageReferrable))
+
+
+class TestARPackage:
+
+    def test_create_autosar_package(self):
+        document = AUTOSAR.getInstance()
+        ar_package_level1 = document.createARPackage("package_level1")
+        assert (ar_package_level1.short_name == "package_level1")
+        assert (ar_package_level1.full_name == "/package_level1")
+        assert (len(ar_package_level1.getARPackages()) == 0)
+
+        ar_find_package = document.find("/package_level1")
+        assert (ar_find_package == ar_package_level1)
+        assert (ar_find_package.short_name == 'package_level1')
+
+        ar_package_level2 = ar_package_level1.createARPackage("package_level2")
+        assert (ar_package_level2.short_name == 'package_level2')
+        assert (ar_package_level2.full_name ==
+                "/package_level1/package_level2")
+        assert (len(ar_package_level1.getARPackages()) == 1)
+        assert (ar_package_level1.getARPackages()[0] == ar_package_level2)
+
+        ar_find_package = document.find("/package_level1/package_level2")
+        assert (ar_find_package == ar_package_level2)
+        assert (ar_find_package.short_name == "package_level2")
+
+    def test_createEcuAbstractionSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createEcuAbstractionSwComponentType(
+            "ecu_abstract_sw_component")
+        assert(sw_component_type.short_name == "ecu_abstract_sw_component")
+        assert(isinstance(sw_component_type, EcuAbstractionSwComponentType))
+
+        find_component_type = document.find(
+            "/AUTOSAR/ecu_abstract_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "ecu_abstract_sw_component")
+
+    def test_createApplicationSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createApplicationSwComponentType(
+            "application_sw_component")
+        assert(sw_component_type.short_name == "application_sw_component")
+
+        assert(isinstance(sw_component_type, ARElement))
+        assert(isinstance(sw_component_type, AtomicSwComponentType))
+        assert(isinstance(sw_component_type, CollectableElement))
+        assert(isinstance(sw_component_type, Identifiable))
+        assert(isinstance(sw_component_type, MultilanguageReferrable))
+        assert(isinstance(sw_component_type, PackageableElement))
+        assert(isinstance(sw_component_type, Referrable))
+        assert(isinstance(sw_component_type, SwComponentType))
+        assert(isinstance(sw_component_type, ApplicationSwComponentType))
+
+        find_component_type = document.find(
+            "/AUTOSAR/application_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "application_sw_component")
+
+    def test_createServiceSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createServiceSwComponentType(
+            "service_sw_component")
+        assert(sw_component_type.short_name == "service_sw_component")
+
+        assert(isinstance(sw_component_type, ARElement))
+        assert(isinstance(sw_component_type, AtomicSwComponentType))
+        assert(isinstance(sw_component_type, CollectableElement))
+        assert(isinstance(sw_component_type, Identifiable))
+        assert(isinstance(sw_component_type, MultilanguageReferrable))
+        assert(isinstance(sw_component_type, PackageableElement))
+        assert(isinstance(sw_component_type, Referrable))
+        assert(isinstance(sw_component_type, SwComponentType))
+        assert(isinstance(sw_component_type, ServiceSwComponentType))
+
+        find_component_type = document.find("/AUTOSAR/service_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "service_sw_component")
+
+    def test_createCompositionSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createCompositionSwComponentType(
+            "composition_sw_component")
+        assert(sw_component_type.short_name == "composition_sw_component")
+
+        assert(isinstance(sw_component_type, ARElement))
+        assert(isinstance(sw_component_type, CollectableElement))
+        assert(isinstance(sw_component_type, Identifiable))
+        assert(isinstance(sw_component_type, MultilanguageReferrable))
+        assert(isinstance(sw_component_type, PackageableElement))
+        assert(isinstance(sw_component_type, Referrable))
+        assert(isinstance(sw_component_type, SwComponentType))
+        assert(isinstance(sw_component_type, CompositionSwComponentType))
+
+        find_component_type = document.find(
+            "/AUTOSAR/composition_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "composition_sw_component")
+
+    def test_createSenderReceiverInterface(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        instance_if = ar_root.createSenderReceiverInterface(
+            "sender_receiver_interface")
+        assert(instance_if.short_name == "sender_receiver_interface")
+
+        assert(isinstance(instance_if, ARElement))
+        assert(isinstance(instance_if, CollectableElement))
+        assert(isinstance(instance_if, DataInterface))
+        assert(isinstance(instance_if, Identifiable))
+        assert(isinstance(instance_if, MultilanguageReferrable))
+        assert(isinstance(instance_if, PackageableElement))
+        assert(isinstance(instance_if, PortInterface))
+        assert(isinstance(instance_if, Referrable))
+        assert(isinstance(instance_if, SenderReceiverInterface))
+
+        find_component = document.find("/AUTOSAR/sender_receiver_interface")
+        assert (find_component == instance_if)
+        assert (find_component.short_name == "sender_receiver_interface")
+
+        assert (len(ar_root.getSenderReceiverInterfaces()) == 1)
+        assert (ar_root.getSenderReceiverInterfaces()[0] == instance_if)
+        assert (ar_root.getSenderReceiverInterfaces()[
+                0].short_name == "sender_receiver_interface")
+
+    def test_createClientServerInterface(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        instance_if = ar_root.createClientServerInterface(
+            "client_server_interface")
+        assert(instance_if.short_name == "client_server_interface")
+        assert(isinstance(instance_if, ClientServerInterface))
+
+        find_component = document.find("/AUTOSAR/client_server_interface")
+        assert (find_component == instance_if)
+        assert (find_component.short_name == "client_server_interface")
+
+        assert (len(ar_root.getClientServerInterfaces()) == 1)
+        assert (ar_root.getClientServerInterfaces()[0] == instance_if)
+        assert (ar_root.getClientServerInterfaces()[
+                0].short_name == "client_server_interface")
+
+    def test_createApplicationPrimitiveDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createApplicationPrimitiveDataType(
+            "application_primitive_data_type")
+        assert(data_type.short_name == "application_primitive_data_type")
+        assert(isinstance(data_type, ApplicationPrimitiveDataType))
+
+        find_component = document.find(
+            "/AUTOSAR/application_primitive_data_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "application_primitive_data_type")
+
+        assert (len(ar_root.getApplicationPrimitiveDataTypes()) == 1)
+        assert (ar_root.getApplicationPrimitiveDataTypes()[0] == data_type)
+        assert (ar_root.getApplicationPrimitiveDataTypes()[
+                0].short_name == "application_primitive_data_type")
+
+    def test_createApplicationRecordDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createApplicationRecordDataType(
+            "application_record_data_type")
+        assert(data_type.short_name == "application_record_data_type")
+        assert(isinstance(data_type, ApplicationRecordDataType))
+
+        find_component = document.find("/AUTOSAR/application_record_data_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "application_record_data_type")
+
+    def test_createImplementationDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createImplementationDataType(
+            "implementation_data_type")
+        assert(data_type.short_name == "implementation_data_type")
+        assert(isinstance(data_type, ImplementationDataType))
+
+        find_component = document.find("/AUTOSAR/implementation_data_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "implementation_data_type")
+
+        assert (len(ar_root.getImplementationDataTypes()) == 1)
+        assert (ar_root.getImplementationDataTypes()[0] == data_type)
+        assert (ar_root.getImplementationDataTypes()[
+                0].short_name == "implementation_data_type")
+
+    def test_createSwBaseType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createSwBaseType("sw_base_type")
+        assert(data_type.short_name == "sw_base_type")
+        assert(isinstance(data_type, SwBaseType))
+
+        find_component = document.find("/AUTOSAR/sw_base_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "sw_base_type")
+
+        assert (len(ar_root.getSwBaseTypes()) == 1)
+        assert (ar_root.getSwBaseTypes()[0] == data_type)
+        assert (ar_root.getSwBaseTypes()[0].short_name == "sw_base_type")
+
+    def test_createDataTypeMappingSet(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        mapping_set = ar_root.createDataTypeMappingSet("data_type_mapping_set")
+        assert(mapping_set.short_name == "data_type_mapping_set")
+        assert(isinstance(mapping_set, DataTypeMappingSet))
+
+        find_component = document.find("/AUTOSAR/data_type_mapping_set")
+        assert (find_component == mapping_set)
+        assert (find_component.short_name == "data_type_mapping_set")
+
+        assert (len(ar_root.getDataTypeMappingSets()) == 1)
+        assert (ar_root.getDataTypeMappingSets()[0] == mapping_set)
+        assert (ar_root.getDataTypeMappingSets()[
+                0].short_name == "data_type_mapping_set")
+
+    def test_createCompuMethod(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        compu_method = ar_root.createCompuMethod("compu_method")
+        assert(compu_method.short_name == "compu_method")
+        assert(isinstance(compu_method, CompuMethod))
+
+        find_component = document.find("/AUTOSAR/compu_method")
+        assert (find_component == compu_method)
+        assert (find_component.short_name == "compu_method")
+
+        assert (len(ar_root.getCompuMethods()) == 1)
+        assert (ar_root.getCompuMethods()[0] == compu_method)
+        assert (ar_root.getCompuMethods()[0].short_name == "compu_method")
+
+    def test_getSwComponentTypes(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+
+        assert (len(ar_root.getSwComponentTypes()) == 4)
+        assert (len(ar_root.getAtomicSwComponentTypes()) == 3)
+        assert (len(ar_root.getCompositionSwComponentTypes()) == 1)

armodel/tests/test_armodel/models/test_ar_ref.py

@@ -0,0 +1,74 @@
+""" Test ARRef """
+
+import pytest
+
+from ....models.ar_ref import ArVariableInImplementationDataInstanceRef, AutosarVariableRef, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
+from ....models.ar_ref import OperationInAtomicSwcInstanceRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, RefType, TRefType, AtpInstanceRef
+from ....models.general_structure import ARObject
+
+
+class TestARRef:
+    def test_RefType(self):
+        ref_type = RefType()
+        assert(ref_type.value == "")
+        assert(ref_type.dest == "")
+
+    def test_TRefType(self):
+        ref_type = TRefType()
+        assert(ref_type.value == "")
+        assert(ref_type.dest == "")
+
+    def test_AutosarVariableRef(self):
+        ref_type = AutosarVariableRef()
+        assert(ref_type != None)
+        assert(ref_type.autosar_variable_iref == None)
+        assert(ref_type.autosar_variable_in_impl_datatype == None)
+        assert(ref_type.local_variable_ref == None)
+
+    def test_AtpInstanceRef(self):
+        with pytest.raises(NotImplementedError) as err:
+            ref_type = AtpInstanceRef()
+        assert(str(err.value) == "AtpInstanceRef is an abstract class.")
+
+    def test_ProvidedPortPrototypeInstanceRef(self):
+        ref_type = PPortInCompositionInstanceRef()
+        assert(ref_type != None)
+        assert(ref_type.context_component_ref == None)
+        assert(ref_type.target_p_port_ref == None)
+
+    def test_RequiredPortPrototypeInstanceRef(self):
+        ref_type = RPortInCompositionInstanceRef()
+        assert(ref_type != None)
+        assert(ref_type.context_component_ref == None)
+        assert(ref_type.target_r_port_ref == None)
+
+    def test_ArVariableInImplementationDataInstanceRef(self):
+        ref_type = ArVariableInImplementationDataInstanceRef()
+        assert(ref_type != None)
+        assert(ref_type.port_prototype_ref == None)
+        assert(ref_type.target_data_prototype_ref == None)
+
+    def test_OperationInAtomicSwcInstanceRef(self):
+        with pytest.raises(NotImplementedError) as err:
+            ref_type = OperationInAtomicSwcInstanceRef()
+        assert(str(err.value) == "OperationInAtomicSwcInstanceRef is an abstract class.")
+
+    def test_POperationInAtomicSwcInstanceRef(self):
+        ref_type = POperationInAtomicSwcInstanceRef()
+        assert(isinstance(ref_type, ARObject))
+        assert(isinstance(ref_type, AtpInstanceRef))
+        assert(isinstance(ref_type, OperationInAtomicSwcInstanceRef))
+        assert(isinstance(ref_type, POperationInAtomicSwcInstanceRef))
+        assert(ref_type != None)
+        assert(ref_type.context_p_port_ref == None)
+        assert(ref_type.target_provided_operation_ref == None)
+
+    def test_ROperationInAtomicSwcInstanceRef(self):
+        ref_type = ROperationInAtomicSwcInstanceRef()
+        assert(isinstance(ref_type, ARObject))
+        assert(isinstance(ref_type, AtpInstanceRef))
+        assert(isinstance(ref_type, OperationInAtomicSwcInstanceRef))
+        assert(isinstance(ref_type, ROperationInAtomicSwcInstanceRef))
+        assert(ref_type != None)
+        assert(ref_type.context_r_port_ref == None)
+        assert(ref_type.target_required_operation_ref == None)

armodel/tests/test_armodel/models/test_bsw_module_template.py

@@ -0,0 +1,46 @@
+import pytest
+
+from ....models.bsw_module_template import BswModuleDescription, BswModuleEntry, BswModuleEntity, BswCalledEntity
+from .... import AUTOSAR
+
+class TestBswModuleDescription:
+    def test_construct(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        bsw_module_description = BswModuleDescription(ar_root, "bsw_module")
+        assert(bsw_module_description != None)
+        assert(bsw_module_description.short_name == "bsw_module")
+
+    def test_category(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        bsw_module_description = BswModuleDescription(ar_root, "bsw_module")
+        with pytest.raises(ValueError) as err:
+            bsw_module_description.category = "invalid"
+        assert(str(err.value) == "Invalid category <invalid> of BswModuleDescription <bsw_module>")
+
+        bsw_module_description.category = "BSW_MODULE"
+        assert(bsw_module_description.category == "BSW_MODULE")
+
+class Test_M2_AUTOSARTemplates_BswModuleTemplate_BswInterfaces:
+    def test_BswModuleEntry(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        entry = BswModuleEntry(ar_root, "bsw_entry")
+        assert(entry != None)
+        assert(entry.short_name == "bsw_entry")
+ 
+class Test_M2_AUTOSARTemplates_BswModuleTemplate_BswBehavior:
+    def test_BswModuleEntity(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        with pytest.raises(NotImplementedError) as err:
+            BswModuleEntity(ar_root, "BswModuleEntity")
+        assert(str(err.value) == "BswModuleEntity is an abstract class.")
+
+    def test_BswCalledEntity(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        entity = BswCalledEntity(ar_root, "bsw_called_entity")
+        assert(entity != None)
+        assert(entity.short_name == "bsw_called_entity")

armodel/tests/test_armodel/models/test_common_structure.py

@@ -0,0 +1,73 @@
+import pytest
+
+from .... import AUTOSAR
+from ....models.common_structure import AbstractImplementationDataTypeElement, ConstantReference, ImplementationDataTypeElement, ValueSpecification, ConstantSpecification, ExecutableEntity
+from ....models.datatype import AbstractImplementationDataType
+from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable
+from ....models.general_structure import MultilanguageReferrable, PackageableElement, Referrable
+
+class Test_M2_AUTOSARTemplates_CommonStructure_Constants:
+    
+    def test_ValueSpecification(self):
+        with pytest.raises(NotImplementedError) as err:
+            ValueSpecification()
+        assert(str(err.value) == "ValueSpecification is an abstract class.")
+
+    def test_ConstantSpecification(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        spec = ConstantSpecification(ar_root, "constant")
+        
+        assert(isinstance(spec, ARElement))
+        assert(isinstance(spec, ARObject))
+        assert(isinstance(spec, CollectableElement))
+        assert(isinstance(spec, Identifiable))
+        assert(isinstance(spec, MultilanguageReferrable))
+        assert(isinstance(spec, PackageableElement))
+        assert(isinstance(spec, Referrable))
+        assert(isinstance(spec, ConstantSpecification)) 
+
+    def test_ConstantReference(self):
+        ref = ConstantReference()
+
+        assert(ref.constant_ref == None)
+
+        assert(isinstance(ref, ARObject))
+        assert(isinstance(ref, ValueSpecification))
+        assert(isinstance(ref, ConstantReference))
+
+class Test_M2_AUTOSARTemplates_CommonStructure_InternalBehavior:
+    def test_ExecutableEntity(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        with pytest.raises(NotImplementedError) as err:
+            ExecutableEntity(ar_root, "ExecutableEntity")
+        assert(str(err.value) == "ExecutableEntity is an abstract class.")
+
+class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
+    def test_ImplementationDataTypeElement(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ImplementationDataTypeElement(ar_root, "implementation_data_type")
+
+        assert(data_type.short_name == "implementation_data_type")
+        assert(data_type.array_size == None)
+        assert(data_type.is_optional == None)
+
+        assert(isinstance(data_type, ARObject))
+        assert(isinstance(data_type, AbstractImplementationDataTypeElement))
+        # assert(isinstance(data_type, AtpClassifier))
+        # assert(isinstance(data_type, AtpFeature))
+        # assert(isinstance(data_type, AtpStructureElement))
+        assert(isinstance(data_type, Identifiable))
+        assert(isinstance(data_type, MultilanguageReferrable))
+        assert(isinstance(data_type, Referrable))
+        assert(isinstance(data_type, ImplementationDataTypeElement))
+
+        sub_type = data_type.createImplementationDataTypeElement("sub_type")
+        assert(sub_type.short_name == "sub_type")
+        assert(isinstance(sub_type, ImplementationDataTypeElement))
+
+        assert(len(data_type.getImplementationDataTypeElements()) == 1)
+        sub_type2 = data_type.getImplementationDataTypeElements()[0]
+        assert(sub_type == sub_type2) 

armodel/tests/test_armodel/models/test_data_dictionary.py

@@ -0,0 +1,29 @@
+import pytest
+
+from ....models.data_dictionary import SwDataDefProps, SwPointerTargetProps
+from ....models.general_structure import ARObject
+
+class Test_M2_MSR_DataDictionary_DataDefProperties:
+    def test_SwDataDefProps(self):
+        props = SwDataDefProps()
+
+        assert(isinstance(props, ARObject))
+        assert(isinstance(props, SwDataDefProps))
+
+        assert(props.base_type_ref == None)
+        assert(props.compu_method_ref == None)
+        assert(props.data_constr_ref == None)                 
+        assert(props.implementation_data_type_ref == None)
+        assert(props.sw_impl_policy == "")
+        assert(props.sw_calibration_access == "")
+        assert(props.sw_pointer_target_props == None)
+
+    def test_SwPointerTargetProps(self):
+        props = SwPointerTargetProps()
+
+        assert(isinstance(props, ARObject))
+        assert(isinstance(props, SwPointerTargetProps))
+
+        assert(props.function_pointer_signature == None)
+        assert(props.sw_data_def_props == None)
+        assert(props.target_category == "")