armodel 1.8.7__py3-none-any.whl → 1.9.1__py3-none-any.whl

armodel/tests/test_armodel/models/test_datatype.py

@@ -1,251 +0,0 @@
-import pytest
-
-from ....models.M2.MSR.AsamHdo.BaseTypes import BaseType, BaseTypeDirectDefinition
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, ApplicationPrimitiveDataType
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationRecordDataType, AutosarDataType, DataTypeMap
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
-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 AbstractImplementationDataType, ImplementationDataType
-from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataTypeElement
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Components import SymbolProps
-from ....models.M2.AUTOSARTemplates.CommonStructure.Implementation import ImplementationProps
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import DataTypeMappingSet
-from ....models.M2.MSR.AsamHdo.BaseTypes import SwBaseType
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from .... import AUTOSAR
-
-
-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 is None)
-
-
-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(TypeError) 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(TypeError) 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(TypeError) 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.swDataDefProps is None)
-
-    def test_ApplicationCompositeDataType(self):
-        with pytest.raises(TypeError) 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.dynamicArraySizeProfile is None)
-        assert (data_type.element is 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.applicationDataTypeRef is None)
-        assert (data_type_map.implementationDataTypeRef is 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 = ar_root.createImplementationDataType("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.subElements == [])
-        assert (data_type.symbolProps is None)
-        assert (data_type.getTypeEmitter() is None)
-
-        element = data_type.createImplementationDataTypeElement("ImplementationDataTypeElement")
-        assert (isinstance(element, ImplementationDataTypeElement))
-        assert (element.short_name == "ImplementationDataTypeElement")
-
-        assert (len(data_type.getSubElements()) == 1)
-        assert (data_type.getSubElements()[0] == element)

armodel/tests/test_armodel/models/test_general_structure.py

@@ -1,56 +0,0 @@
-import pytest
-
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, PackageableElement
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpFeature
-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.AutosarTopLevelStructure import AUTOSAR
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Limit
-
-
-class TestGeneralStructure:
-    def test_ar_object(self):
-        with pytest.raises(TypeError) as err:
-            ARObject()
-        assert (str(err.value) == "ARObject is an abstract class.")
-
-    def test_Referrable(self):
-        with pytest.raises(TypeError) as err:
-            Referrable(AUTOSAR.getInstance(), "ar_referrable")
-        assert (str(err.value) == "Referrable is an abstract class.")
-
-    def test_MultilanguageReferrable(self):
-        with pytest.raises(TypeError) as err:
-            MultilanguageReferrable(AUTOSAR.getInstance(), "MultilanguageReferrable")
-        assert (str(err.value) == "MultilanguageReferrable is an abstract class.")
-
-    def test_CollectableElement(self):
-        with pytest.raises(TypeError) as err:
-            CollectableElement()
-        assert (str(err.value) == "CollectableElement is an abstract class.")
-
-    def test_Identifiable(self):
-        with pytest.raises(TypeError) as err:
-            Identifiable(AUTOSAR.getInstance(), "ar_identifiable")
-        assert (str(err.value) == "Identifiable is an abstract class.")
-
-    def test_AtpFeature(self):
-        with pytest.raises(TypeError) as err:
-            AtpFeature(AUTOSAR.getInstance(), "AtpFeature")
-        assert (str(err.value) == "AtpFeature is an abstract class.")
-
-    def test_packageable_element(self):
-        with pytest.raises(TypeError) 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(TypeError) 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 is None)
-        assert (limit.intervalType is None)

armodel/tests/test_armodel/models/test_implementation.py

@@ -1,27 +0,0 @@
-
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
-from ....models.M2.AUTOSARTemplates.CommonStructure.Implementation import Code
-from ....models.M2.AUTOSARTemplates.AutosarTopLevelStructure 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

@@ -1,79 +0,0 @@
-import pytest
-
-from .... import AUTOSAR
-from ....models.M2.MSR.AsamHdo.ComputationMethod import Compu, CompuConst, CompuConstContent, CompuConstNumericContent, CompuConstTextContent
-from ....models.M2.MSR.AsamHdo.ComputationMethod import CompuContent, CompuScale, CompuScales
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-
-
-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.compuContent is None)
-        assert (compu.compuDefaultValue is 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 is None)
-
-    def test_CompuConstNumericContent(self):
-        content = CompuConstNumericContent()
-
-        assert (isinstance(content, ARObject))
-        assert (isinstance(content, CompuConstContent))
-        assert (isinstance(content, CompuConstNumericContent))
-
-        assert (content.v is None)
-
-    def test_CompuConst(self):
-        compu_const = CompuConst()
-
-        assert (isinstance(compu_const, ARObject))
-        assert (isinstance(compu_const, CompuConst))
-
-        assert (compu_const.compuConstContentType is None)
-
-    def test_CompuScale(self):
-        compu_scale = CompuScale()
-
-        assert (isinstance(compu_scale, ARObject))
-        assert (isinstance(compu_scale, CompuScale))
-
-        assert (compu_scale.compuContent is None)
-        assert (compu_scale.lowerLimit is None)
-        assert (compu_scale.upperLimit is None)
-        assert (compu_scale.compuInverseValue is None)
-        assert (compu_scale.compuScaleContents is None)
-
-    def test_CompuScales(self):
-        compu_scales = CompuScales()
-
-        assert (isinstance(compu_scales, ARObject))
-        assert (isinstance(compu_scales, CompuScales))
-
-        assert (len(compu_scales.compuScales) == 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

@@ -1,202 +0,0 @@
-import pytest
-
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import PackageableElement
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpFeature
-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.AutosarTopLevelStructure import AUTOSAR
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import AtpPrototype, AutosarDataPrototype, DataPrototype
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ApplicationError, ArgumentDataPrototype, ClientServerInterface
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ClientServerOperation, DataInterface, NvDataInterface
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import 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.getShortName() == "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.getShortName() == "element")
-        assert (len(sr_if.getDataElements()) == 1)
-
-        element2 = sr_if.getDataElement("element")
-        assert (element == element2)
-
-    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() is None)
-        assert (prototype.getServerArgumentImplPolicy() is 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 (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 = 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.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))
-
-        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

@@ -1,15 +0,0 @@
-import pytest
-
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import PPortComSpec, RPortComSpec
-
-
-class Test_PortPrototype:
-    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.")