armodel 1.7.9__py3-none-any.whl → 1.8.1__py3-none-any.whl

armodel/tests/test_armodel/models/test_datatype.py

@@ -1,20 +1,16 @@
 import pytest
 
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType, DataTypeMap
-
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
-
 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, ImplementationDataTypeElement
+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
@@ -22,27 +18,30 @@ from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes impor
 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.")
+        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 (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)
 
-        assert(prototype.parent == ar_root)
-        assert(prototype.short_name == "SymbolProps")
-        assert(prototype.symbol == None)
 
 class Test_M2_MSR_AsamHdo_BaseTypes:
     def test_BaseType(self):
@@ -50,164 +49,164 @@ class Test_M2_MSR_AsamHdo_BaseTypes:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             BaseType(ar_root, "BaseType")
-        assert(str(err.value) == "BaseType is an abstract class.")
+        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 (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))
 
-        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:
+        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.")
+        assert (str(err.value) == "AtpType is an abstract class.")
 
     def test_AutosarDataType(self):
-        with pytest.raises(NotImplementedError) as err:
+        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.")
+        assert (str(err.value) == "AutosarDataType is an abstract class.")
 
     def test_ApplicationDataType(self):
-        with pytest.raises(NotImplementedError) as err:
+        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.")
+        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 == None)
+        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(NotImplementedError) as err:
+        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.")
+        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 == None)
-        assert(data_type.element == None)
+        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")
+        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")
+        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 (isinstance(data_type_map, ARObject))
+        assert (isinstance(data_type_map, DataTypeMap))
 
-        assert(data_type_map.applicationDataTypeRef == None)
-        assert(data_type_map.implementationDataTypeRef == None)
+        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)
+        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)
-
+        assert (len(data_type_mapping_set.getDataTypeMaps()) == 1)
+        assert (data_type_mapping_set.getDataTypeMaps()[0] == data_type_map)
 
 
 class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
@@ -216,38 +215,37 @@ class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             AbstractImplementationDataType(ar_root, "AbstractImplementationDataType")
-        assert(str(err.value) == "AbstractImplementationDataType is an abstract class.")
+        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.subElements == [])
-        assert(data_type.symbolProps == None)
-        assert(data_type.typeEmitter == None)
+        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 (isinstance(element, ImplementationDataTypeElement))
+        assert (element.short_name == "ImplementationDataTypeElement")
 
-        assert(len(data_type.getImplementationDataTypeElements()) == 1)
-        assert(data_type.getImplementationDataTypeElements()[0] == element)
-        
+        assert (len(data_type.getSubElements()) == 1)
+        assert (data_type.getSubElements()[0] == element)

armodel/tests/test_armodel/models/test_general_structure.py

@@ -13,48 +13,49 @@ from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArOb
 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(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             ARObject()
-        assert(str(err.value) == "ARObject is an abstract class.")
+        assert (str(err.value) == "ARObject is an abstract class.")
 
     def test_Referrable(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             Referrable(AUTOSAR.getInstance(), "ar_referrable")
-        assert(str(err.value) == "Referrable is an abstract class.")
+        assert (str(err.value) == "Referrable is an abstract class.")
 
     def test_MultilanguageReferrable(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             MultilanguageReferrable(AUTOSAR.getInstance(), "MultilanguageReferrable")
-        assert(str(err.value) == "MultilanguageReferrable is an abstract class.")
+        assert (str(err.value) == "MultilanguageReferrable is an abstract class.")
 
     def test_CollectableElement(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             CollectableElement()
-        assert(str(err.value) == "CollectableElement is an abstract class.")
+        assert (str(err.value) == "CollectableElement is an abstract class.")
 
     def test_Identifiable(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             Identifiable(AUTOSAR.getInstance(), "ar_identifiable")
-        assert(str(err.value) == "Identifiable is an abstract class.")
+        assert (str(err.value) == "Identifiable is an abstract class.")
 
     def test_AtpFeature(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             AtpFeature(AUTOSAR.getInstance(), "AtpFeature")
-        assert(str(err.value) == "AtpFeature is an abstract class.")
+        assert (str(err.value) == "AtpFeature is an abstract class.")
 
     def test_packageable_element(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             PackageableElement(AUTOSAR.getInstance(), "ar_packageable_element")
-        assert(str(err.value) == "PackageableElement is an abstract class.")
+        assert (str(err.value) == "PackageableElement is an abstract class.")
 
     def test_ar_element(self):
-        with pytest.raises(NotImplementedError) as err:
+        with pytest.raises(TypeError) as err:
             ARElement(AUTOSAR.getInstance(), "ar_element")
-        assert(str(err.value) == "ARElement is an abstract class.")
+        assert (str(err.value) == "ARElement is an abstract class.")
 
     def test_limit(self):
         limit = Limit()
-        assert(limit.value == None)
-        assert(limit.intervalType == None)
+        assert (limit.value is None)
+        assert (limit.intervalType is None)

armodel/tests/test_armodel/models/test_port_interface.py

@@ -96,22 +96,18 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_PortInterface:
         assert (isinstance(sr_if, Referrable))
         assert (isinstance(sr_if, SenderReceiverInterface))
 
-        assert (sr_if.short_name == "sr_if")
+        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.short_name == "element")
+        assert (element.getShortName() == "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")

armodel/tests/test_armodel/parser/test_arxml_parser.py

@@ -5,11 +5,11 @@ 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/*")
+        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/*")

armodel/writer/abstract_arxml_writer.py

@@ -8,7 +8,8 @@ import logging
 import xml.etree.cElementTree as ET
 
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, ARLiteral, ARNumerical, Integer, TimeValue
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, ARLiteral, ARNumerical, DateTime, Integer
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RevisionLabelString, TimeValue
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARBoolean
 
 
@@ -81,7 +82,10 @@ class AbstractARXMLWriter:
     def setChildElementOptionalPositiveInteger(self, element: ET.Element, key: str, value: Integer):
         self.setChildElementOptionalNumericalValue(element, key, value)
     
-    def setChildElementOptionalRevisionLabelString(self, element: ET.Element, key: str, literal: ARLiteral):
+    def setChildElementOptionalRevisionLabelString(self, element: ET.Element, key: str, literal: RevisionLabelString):
+        self.setChildElementOptionalLiteral(element, key, literal)
+
+    def setChildElementOptionalDataTime(self, element: ET.Element, key: str, literal: DateTime):
         self.setChildElementOptionalLiteral(element, key, literal)
 
     def setChildElementOptionalRefType(self, parent: ET.Element, child_tag_name: str, ref: RefType):