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

armodel/tests/test_armodel/models/test_datatype.py

@@ -0,0 +1,239 @@
+import pytest
+
+from .... import AUTOSAR
+from ....models import datatype
+from ....models.common_structure import ImplementationDataTypeElement
+from ....models.data_prototype import ApplicationRecordElement
+from ....models.datatype import AbstractImplementationDataType, ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AtpType, AutosarDataType, BaseType, DataTypeMap, DataTypeMappingSet, ImplementationDataType, ImplementationProps, SymbolProps
+from ....models.datatype import BaseTypeDirectDefinition, SwBaseType
+from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, Referrable
+
+class Test_M2_AUTOSARTemplates_CommonStructure_Implementation:
+    def test_ImplementationProps(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            ImplementationProps(ar_root, "ImplementationProps")
+        assert(str(err.value) == "ImplementationProps is an abstract class.")
+
+    def test_SymbolProps(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        prototype = SymbolProps(ar_root, "SymbolProps")
+
+        assert(isinstance(prototype, ARObject))
+        assert(isinstance(prototype, ImplementationProps))
+        assert(isinstance(prototype, Referrable))
+        assert(isinstance(prototype, SymbolProps))
+
+        assert(prototype.parent == ar_root)
+        assert(prototype.short_name == "SymbolProps")
+        assert(prototype.symbol == "")
+
+class Test_M2_MSR_AsamHdo_BaseTypes:
+    def test_BaseType(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            BaseType(ar_root, "BaseType")
+        assert(str(err.value) == "BaseType is an abstract class.")
+
+    def test_SwBaseType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        base_type = SwBaseType(ar_root, "SwBaseType")
+
+        assert(isinstance(base_type, ARElement))
+        assert(isinstance(base_type, ARObject))
+        assert(isinstance(base_type, CollectableElement))
+        assert(isinstance(base_type, Identifiable))
+        assert(isinstance(base_type, MultilanguageReferrable))
+        assert(isinstance(base_type, PackageableElement))
+        assert(isinstance(base_type, Referrable))
+        assert(isinstance(base_type, SwBaseType))
+
+        assert(base_type.parent == ar_root)
+        assert(base_type.short_name == "SwBaseType")
+        assert(isinstance(base_type.baseTypeDefinition, BaseTypeDirectDefinition))
+
+class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
+    def test_AtpType(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            AtpType(ar_root, "AtpType")
+        assert(str(err.value) == "AtpType is an abstract class.")
+
+    def test_AutosarDataType(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            AutosarDataType(ar_root, "AutosarDataType")
+        assert(str(err.value) == "AutosarDataType is an abstract class.")
+
+    def test_ApplicationDataType(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            ApplicationDataType(ar_root, "ApplicationDataType")
+        assert(str(err.value) == "ApplicationDataType is an abstract class.")
+
+    def test_ApplicationPrimitiveDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ApplicationPrimitiveDataType(ar_root, "ApplicationPrimitiveDataType")
+
+        assert(isinstance(data_type, ARElement))
+        assert(isinstance(data_type, ARObject))
+        # assert(isinstance(data_type, AtpBlueprint))
+        # assert(isinstance(data_type, AtpBlueprintable))
+        # assert(isinstance(data_type, AtpClassifier))
+        assert(isinstance(data_type, AtpType))
+        assert(isinstance(data_type, AutosarDataType))
+        assert(isinstance(data_type, CollectableElement))
+        assert(isinstance(data_type, Identifiable))
+        assert(isinstance(data_type, MultilanguageReferrable))
+        assert(isinstance(data_type, PackageableElement))
+        assert(isinstance(data_type, Referrable))
+        assert(isinstance(data_type, ApplicationPrimitiveDataType))
+
+        assert(data_type.parent == ar_root)
+        assert(data_type.short_name == "ApplicationPrimitiveDataType")
+        assert(data_type.sw_data_def_props == None)
+
+    def test_ApplicationCompositeDataType(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            ApplicationCompositeDataType(ar_root, "ApplicationCompositeDataType")
+        assert(str(err.value) == "ApplicationCompositeDataType is an abstract class.")
+
+    def test_ApplicationArrayDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ApplicationArrayDataType(ar_root, "ApplicationArrayDataType")
+
+        assert(isinstance(data_type, ARElement))
+        assert(isinstance(data_type, ARObject))
+        assert(isinstance(data_type, ApplicationDataType))
+        # assert(isinstance(data_type, AtpBlueprint))
+        # assert(isinstance(data_type, AtpBlueprintable))
+        # assert(isinstance(data_type, AtpClassifier))
+        assert(isinstance(data_type, AtpType))
+        assert(isinstance(data_type, AutosarDataType))
+        assert(isinstance(data_type, CollectableElement))
+        assert(isinstance(data_type, Identifiable))
+        assert(isinstance(data_type, MultilanguageReferrable))
+        assert(isinstance(data_type, PackageableElement))
+        assert(isinstance(data_type, Referrable))
+        assert(isinstance(data_type, ApplicationArrayDataType))
+
+        assert(data_type.parent == ar_root)
+        assert(data_type.short_name == "ApplicationArrayDataType")
+        assert(data_type.dynamic_array_size_profile == None)
+        assert(data_type.element == None)
+
+    def test_ApplicationRecordDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ApplicationRecordDataType(ar_root, "ApplicationRecordDataType")
+
+        assert(isinstance(data_type, ARElement))
+        assert(isinstance(data_type, ARObject))
+        assert(isinstance(data_type, ApplicationDataType))
+        # assert(isinstance(data_type, AtpBlueprint))
+        # assert(isinstance(data_type, AtpBlueprintable))
+        # assert(isinstance(data_type, AtpClassifier))
+        assert(isinstance(data_type, AtpType))
+        assert(isinstance(data_type, AutosarDataType))
+        assert(isinstance(data_type, CollectableElement))
+        assert(isinstance(data_type, Identifiable))
+        assert(isinstance(data_type, MultilanguageReferrable))
+        assert(isinstance(data_type, PackageableElement))
+        assert(isinstance(data_type, Referrable))
+        assert(isinstance(data_type, ApplicationRecordDataType))
+
+        assert(data_type.parent == ar_root)
+        assert(data_type.short_name == "ApplicationRecordDataType")
+
+        element = data_type.createApplicationRecordElement("element")
+        assert(isinstance(element, ApplicationRecordElement))
+        assert(element.short_name == "element")
+
+    def test_DataTypeMap(self):
+        data_type_map = DataTypeMap()
+
+        assert(isinstance(data_type_map, ARObject))
+        assert(isinstance(data_type_map, DataTypeMap))
+
+        assert(data_type_map.application_data_type_ref == None)
+        assert(data_type_map.implementation_data_type_ref == None)
+
+    def test_DataTypeMappingSet(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type_mapping_set = DataTypeMappingSet(ar_root, "DataTypeMappingSet")
+
+        assert(isinstance(data_type_mapping_set, ARElement))
+        assert(isinstance(data_type_mapping_set, ARObject))
+        # assert(isinstance(data_type_mapping_set, AtpBlueprint))
+        # assert(isinstance(data_type_mapping_set, AtpBlueprintable))
+        assert(isinstance(data_type_mapping_set, CollectableElement))
+        assert(isinstance(data_type_mapping_set, Identifiable))
+        assert(isinstance(data_type_mapping_set, MultilanguageReferrable))
+        assert(isinstance(data_type_mapping_set, PackageableElement))
+        assert(isinstance(data_type_mapping_set, Referrable))
+        assert(isinstance(data_type_mapping_set, DataTypeMappingSet))
+
+        assert(data_type_mapping_set.parent == ar_root)
+        assert(data_type_mapping_set.short_name == "DataTypeMappingSet")
+        assert(len(data_type_mapping_set._dataTypeMaps) == 0)
+
+        data_type_map = DataTypeMap()
+        data_type_mapping_set.addDataTypeMap(data_type_map)
+        assert(len(data_type_mapping_set.getDataTypeMaps()) == 1)
+        assert(data_type_mapping_set.getDataTypeMaps()[0] == data_type_map)
+
+
+
+class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
+    def test_AbstractImplementationDataType(self):
+        with pytest.raises(NotImplementedError) as err:
+            document = AUTOSAR.getInstance()
+            ar_root = document.createARPackage("AUTOSAR")
+            AbstractImplementationDataType(ar_root, "AbstractImplementationDataType")
+        assert(str(err.value) == "AbstractImplementationDataType is an abstract class.")
+
+    def test_ImplementationDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ImplementationDataType(ar_root, "ImplementationDataType")
+
+        assert(isinstance(data_type, ARElement))
+        assert(isinstance(data_type, ARObject))
+        assert(isinstance(data_type, AbstractImplementationDataType,))
+        # assert(isinstance(data_type, AtpBlueprint))
+        # assert(isinstance(data_type, AtpBlueprintable))
+        # assert(isinstance(data_type, AtpClassifier))
+        assert(isinstance(data_type, AtpType))
+        assert(isinstance(data_type, AutosarDataType))
+        assert(isinstance(data_type, CollectableElement))
+        assert(isinstance(data_type, Identifiable))
+        assert(isinstance(data_type, MultilanguageReferrable))
+        assert(isinstance(data_type, PackageableElement))
+        assert(isinstance(data_type, Referrable))
+        assert(isinstance(data_type, ImplementationDataType))
+
+        assert(data_type.parent == ar_root)
+        assert(data_type.short_name == "ImplementationDataType")
+        assert(data_type.sub_elements == [])
+        assert(data_type.symbol_props == None)
+        assert(data_type._type_emitter == None)
+
+        element = data_type.createImplementationDataTypeElement("ImplementationDataTypeElement")
+        assert(isinstance(element, ImplementationDataTypeElement))
+        assert(element.short_name == "ImplementationDataTypeElement")
+
+        assert(len(data_type.getImplementationDataTypeElements()) == 1)
+        assert(data_type.getImplementationDataTypeElements()[0] == element)
+        

armodel/tests/test_armodel/models/test_general_structure.py

@@ -0,0 +1,50 @@
+import pytest
+
+from ....models.ar_package import AUTOSAR
+from ....models.general_structure import ARElement, ARObject, AtpFeature, CollectableElement, Identifiable, Limit, MultilanguageReferrable, PackageableElement, Referrable
+
+class TestGeneralStructure:
+    def test_ar_object(self):
+        with pytest.raises(NotImplementedError) as err:
+            ARObject()
+        assert(str(err.value) == "ARObject is an abstract class.")
+
+    def test_Referrable(self):
+        with pytest.raises(NotImplementedError) as err:
+            Referrable(AUTOSAR.getInstance(), "ar_referrable")
+        assert(str(err.value) == "Referrable is an abstract class.")
+
+    def test_MultilanguageReferrable(self):
+        with pytest.raises(NotImplementedError) as err:
+            MultilanguageReferrable(AUTOSAR.getInstance(), "MultilanguageReferrable")
+        assert(str(err.value) == "MultilanguageReferrable is an abstract class.")
+
+    def test_CollectableElement(self):
+        with pytest.raises(NotImplementedError) as err:
+            CollectableElement()
+        assert(str(err.value) == "CollectableElement is an abstract class.")
+
+    def test_Identifiable(self):
+        with pytest.raises(NotImplementedError) as err:
+            Identifiable(AUTOSAR.getInstance(), "ar_identifiable")
+        assert(str(err.value) == "Identifiable is an abstract class.")
+
+    def test_AtpFeature(self):
+        with pytest.raises(NotImplementedError) as err:
+            AtpFeature(AUTOSAR.getInstance(), "AtpFeature")
+        assert(str(err.value) == "AtpFeature is an abstract class.")
+
+    def test_packageable_element(self):
+        with pytest.raises(NotImplementedError) as err:
+            PackageableElement(AUTOSAR.getInstance(), "ar_packageable_element")
+        assert(str(err.value) == "PackageableElement is an abstract class.")
+
+    def test_ar_element(self):
+        with pytest.raises(NotImplementedError) as err:
+            ARElement(AUTOSAR.getInstance(), "ar_element")
+        assert(str(err.value) == "ARElement is an abstract class.")
+
+    def test_limit(self):
+        limit = Limit()
+        assert(limit.value == None)
+        assert(limit.intervalType == None)

armodel/tests/test_armodel/models/test_implementation.py

@@ -0,0 +1,26 @@
+
+from ....models.implementation import AutosarEngineeringObject, Code
+from ....models.ar_package import AUTOSAR
+
+
+class TestImplementation:
+    def test_code(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        code = Code(ar_root, "code")
+        assert(code.short_name == "code")
+
+        data = [
+            ["Autosar::include::BswM.h", "SWHDR"],
+            ["Autosar::src::BswM.c", "SWSRC"]
+        ]
+
+        for item in data:
+            engineering_obj = AutosarEngineeringObject()
+            engineering_obj.setShortLabel(item[0])\
+                           .setCategory(item[1])
+            code.addArtifactDescriptor(engineering_obj)
+
+        assert(len(code.getArtifactDescriptors()) == 2)
+        assert(len(code.getArtifactDescriptors("SWHDR")) == 1)
+        assert(len(code.getArtifactDescriptors("SWSRC")) == 1)

armodel/tests/test_armodel/models/test_m2_msr.py

@@ -0,0 +1,77 @@
+import pytest
+
+from .... import AUTOSAR
+from ....models.general_structure import ARObject
+from ....models.m2_msr import Compu, CompuConst, CompuConstContent, CompuConstNumericContent, CompuConstTextContent, CompuContent, CompuScale, CompuScales
+
+class Test_M2_MSR_AsamHdo_ComputationMethod:
+    def test_CompuContent(self):
+        with pytest.raises(NotImplementedError) as err:
+            CompuContent()
+        assert(str(err.value) == "CompuContent is an abstract class.")
+
+    def test_Compu(self):
+        compu = Compu()
+
+        assert(isinstance(compu, ARObject))
+        assert(isinstance(compu, Compu))
+
+        assert(compu.compu_content == None)
+        assert(compu.compu_default_value == None)
+
+    def test_CompuConstContent(self):
+        with pytest.raises(NotImplementedError) as err:
+            CompuConstContent()
+        assert(str(err.value) == "CompuConstContent is an abstract class.")
+
+    def test_CompuConstTextContent(self):
+        content = CompuConstTextContent()
+
+        assert(isinstance(content, ARObject))
+        assert(isinstance(content, CompuConstContent))
+        assert(isinstance(content, CompuConstTextContent))
+
+        assert(content.vt == None)
+
+    def test_CompuConstNumericContent(self):
+        content = CompuConstNumericContent()
+
+        assert(isinstance(content, ARObject))
+        assert(isinstance(content, CompuConstContent))
+        assert(isinstance(content, CompuConstNumericContent))
+
+        assert(content.v == None)
+
+    def test_CompuConst(self):
+        compu_const = CompuConst()
+
+        assert(isinstance(compu_const, ARObject))
+        assert(isinstance(compu_const, CompuConst))
+
+        assert(compu_const.compu_const_content_type == None)
+
+    def test_CompuScale(self):
+        compu_scale = CompuScale()
+
+        assert(isinstance(compu_scale, ARObject))
+        assert(isinstance(compu_scale, CompuScale))
+
+        assert(compu_scale.compu_content == None)
+        assert(compu_scale.lowerLimit == None)
+        assert(compu_scale.upperLimit == None)
+        assert(compu_scale.compuInverseValue == None)
+        assert(compu_scale.compuScaleContents == None)
+
+    def test_CompuScales(self):
+        compu_scales = CompuScales()
+
+        assert(isinstance(compu_scales, ARObject))
+        assert(isinstance(compu_scales, CompuScales))
+
+        assert(len(compu_scales.compu_scales) == 0)
+
+        compu_scale = CompuScale()
+        compu_scales.addCompuScale(compu_scale)
+
+        assert(len(compu_scales.getCompuScales()) == 1)
+        assert(compu_scales.getCompuScales()[0] == compu_scale)

armodel/tests/test_armodel/models/test_port_interface.py

@@ -0,0 +1,198 @@
+import pytest
+
+from ....models.ar_package import AUTOSAR
+from ....models.ar_ref import RefType
+from ....models.data_prototype import AtpPrototype, AutosarDataPrototype, DataPrototype, VariableDataPrototype
+from ....models.datatype import AtpType
+from ....models.general_structure import ARElement, ARObject, AtpFeature, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, Referrable
+from ....models.port_interface import ApplicationError, ArgumentDataPrototype, ClientServerInterface, ClientServerOperation, DataInterface, NvDataInterface, ParameterInterface, PortInterface, SenderReceiverInterface
+
+
+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.")
+
+    def test_DataInterface(self):
+        with pytest.raises(NotImplementedError) as err:
+            DataInterface(AUTOSAR.getInstance(), "DataInterface")
+        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")
+
+    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")
+
+    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)
+
+        element = sr_if.createDataElement("element")
+        assert(isinstance(element, VariableDataPrototype))
+        assert(element.short_name == "element")
+        assert(len(sr_if.getDataElements()) == 1)
+
+        element2 = sr_if.getDataElement("element")
+        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.")
+
+    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.parent == ar_root)
+        assert(prototype.short_name == "ArgumentDataPrototype")
+        assert(prototype.direction == "")
+        assert(prototype.server_argument_impl_policy == "")
+
+    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(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)
+
+        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)
+
+    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))
+
+        element = cs_if.createOperation("operation")
+        assert(isinstance(element, ClientServerOperation))
+        assert(element.short_name == "operation")
+        assert(len(cs_if.getOperations()) == 1)
+
+        element2 = cs_if.getOperations()[0]
+        assert(element == element2)
+
+        element = cs_if.createApplicationError("error")
+        assert(isinstance(element, ApplicationError))
+        assert(element.short_name == "error")
+        assert(len(cs_if.getPossibleErrors()) == 1)
+
+        element2 = cs_if.getPossibleErrors()[0]
+        assert(element == element2)

armodel/tests/test_armodel/models/test_port_prototype.py

@@ -0,0 +1,14 @@
+import pytest
+
+from ....models.port_prototype import PPortComSpec, RPortComSpec
+
+class Test_PortProtype:
+    def test_PPortComSpec(self):
+        with pytest.raises(NotImplementedError) as err:
+            PPortComSpec()
+        assert(str(err.value) == "PPortComSpec is an abstract class.")
+
+    def test_RPortComSpec(self):
+        with pytest.raises(NotImplementedError) as err:
+            RPortComSpec()
+        assert(str(err.value) == "RPortComSpec is an abstract class.")

armodel/tests/test_armodel/parser/test_arxml_parser.py

@@ -0,0 +1,15 @@
+
+from ....parser.arxml_parser import ARXMLParser
+
+
+class TestARXMLParser:
+    def test_convert_find_key(self):
+        parser = ARXMLParser()
+        assert(parser.convert_find_key("ELEMENTS") == "xmlns:ELEMENTS")
+        assert(parser.convert_find_key("ELEMENTS/*") == "xmlns:ELEMENTS/*")
+        assert(parser.convert_find_key("./ELEMENTS") == "./xmlns:ELEMENTS")
+        assert(parser.convert_find_key("./ELEMENTS/*") == "./xmlns:ELEMENTS/*")
+        assert(parser.convert_find_key("A/B") == "xmlns:A/xmlns:B")
+        assert(parser.convert_find_key("A/B/*") == "xmlns:A/xmlns:B/*")
+        assert(parser.convert_find_key("./A/B") == "./xmlns:A/xmlns:B")
+        assert(parser.convert_find_key("./A/B/*") == "./xmlns:A/xmlns:B/*")