armodel 1.8.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

armodel/tests/test_armodel/models/test_common_structure.py

@@ -1,47 +1,47 @@
 import pytest
 
+from ....models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
 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 AbstractImplementationDataTypeElement, ImplementationDataTypeElement
-from .... import AUTOSAR
+from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import AbstractImplementationDataTypeElement
+from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataTypeElement
 from ....models.M2.AUTOSARTemplates.CommonStructure import ConstantReference, ConstantSpecification, ValueSpecification
 from ....models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import PackageableElement
 
+
 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.")
+        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)) 
+
+        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.getConstantRef() == None)
+        assert (ref.getConstantRef() is None)
+
+        assert (isinstance(ref, ARObject))
+        assert (isinstance(ref, ValueSpecification))
+        assert (isinstance(ref, ConstantReference))
 
-        assert(isinstance(ref, ARObject))
-        assert(isinstance(ref, ValueSpecification))
-        assert(isinstance(ref, ConstantReference))
 
 class Test_M2_AUTOSARTemplates_CommonStructure_InternalBehavior:
     def test_ExecutableEntity(self):
@@ -49,32 +49,34 @@ class Test_M2_AUTOSARTemplates_CommonStructure_InternalBehavior:
         ar_root = document.createARPackage("AUTOSAR")
         with pytest.raises(NotImplementedError) as err:
             ExecutableEntity(ar_root, "ExecutableEntity")
-        assert(str(err.value) == "ExecutableEntity is an abstract class.")
+        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")
+        data_type = ImplementationDataTypeElement(
+            ar_root, "implementation_data_type")
 
-        assert(data_type.getShortName() == "implementation_data_type")
-        assert(data_type.getArraySize() == None)
-        assert(data_type.getIsOptional() == None)
+        assert (data_type.getShortName() == "implementation_data_type")
+        assert (data_type.getArraySize() is None)
+        assert (data_type.getIsOptional() is None)
 
-        assert(isinstance(data_type, ARObject))
-        assert(isinstance(data_type, AbstractImplementationDataTypeElement))
+        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))
+        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.getShortName() == "sub_type")
-        assert(isinstance(sub_type, ImplementationDataTypeElement))
+        assert (sub_type.getShortName() == "sub_type")
+        assert (isinstance(sub_type, ImplementationDataTypeElement))
 
-        assert(len(data_type.getImplementationDataTypeElements()) == 1)
+        assert (len(data_type.getImplementationDataTypeElements()) == 1)
         sub_type2 = data_type.getImplementationDataTypeElements()[0]
-        assert(sub_type == sub_type2) 
+        assert (sub_type == sub_type2)

armodel/tests/test_armodel/models/test_datatype.py

@@ -72,21 +72,21 @@ class Test_M2_MSR_AsamHdo_BaseTypes:
 
 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.")
 
     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.")
 
     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")
@@ -116,7 +116,7 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
         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")

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):