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

armodel/tests/test_armodel/models/test_data_dictionary.py

@@ -1,30 +0,0 @@
-import pytest
-
-from ....models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, SwPointerTargetProps
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-
-
-class Test_M2_MSR_DataDictionary_DataDefProperties:
-    def test_SwDataDefProps(self):
-        props = SwDataDefProps()
-
-        assert (isinstance(props, ARObject))
-        assert (isinstance(props, SwDataDefProps))
-
-        assert (props.baseTypeRef is None)
-        assert (props.compuMethodRef is None)
-        assert (props.dataConstrRef is None)
-        assert (props.implementationDataTypeRef is None)
-        assert (props.swImplPolicy is None)
-        assert (props.swCalibrationAccess is None)
-        assert (props.swPointerTargetProps is None)
-
-    def test_SwPointerTargetProps(self):
-        props = SwPointerTargetProps()
-
-        assert (isinstance(props, ARObject))
-        assert (isinstance(props, SwPointerTargetProps))
-
-        assert (props.getFunctionPointerSignatureRef() is None)
-        assert (props.getSwDataDefProps() is None)
-        assert (props.getTargetCategory() is None)

armodel/tests/test_armodel/models/test_data_prototype.py

@@ -1,93 +0,0 @@
-import pytest
-
-from .... import AUTOSAR
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable, Referrable
-from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationArrayElement
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationCompositeElementDataPrototype
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import AtpPrototype, AutosarDataPrototype
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import DataPrototype, VariableDataPrototype
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpFeature
-
-
-class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_DataPrototypes:
-
-    def test_AtpPrototype(self):
-        with pytest.raises(NotImplementedError) as err:
-            document = AUTOSAR.getInstance()
-            ar_root = document.createARPackage("AUTOSAR")
-            AtpPrototype(ar_root, "prototype")
-        assert (str(err.value) == "AtpPrototype is an abstract class.")
-
-    def test_DataPrototype(self):
-        with pytest.raises(NotImplementedError) as err:
-            document = AUTOSAR.getInstance()
-            ar_root = document.createARPackage("AUTOSAR")
-            DataPrototype(ar_root, "prototype")
-        assert (str(err.value) == "DataPrototype is an abstract class.")
-
-    def test_AutosarDataPrototype(self):
-        with pytest.raises(NotImplementedError) as err:
-            document = AUTOSAR.getInstance()
-            ar_root = document.createARPackage("AUTOSAR")
-            AutosarDataPrototype(ar_root, "prototype")
-        assert (str(err.value) == "AutosarDataPrototype is an abstract class.")
-
-    def test_VariableDataPrototype(self):
-        document = AUTOSAR.getInstance()
-        ar_root = document.createARPackage("AUTOSAR")
-        prototype = VariableDataPrototype(ar_root, "prototype")
-
-        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 (prototype.parent == ar_root)
-        assert (prototype.short_name == "prototype")
-        assert (prototype.typeTRef is None)
-
-    def test_ApplicationCompositeElementDataPrototype(self):
-        with pytest.raises(NotImplementedError) as err:
-            document = AUTOSAR.getInstance()
-            ar_root = document.createARPackage("AUTOSAR")
-            ApplicationCompositeElementDataPrototype(
-                ar_root, "application_composition_element_data_prototype")
-        assert (str(err.value) == "ApplicationCompositeElementDataPrototype is an abstract class.")
-
-    def test_ApplicationArrayElement(self):
-        document = AUTOSAR.getInstance()
-        ar_root = document.createARPackage("AUTOSAR")
-        prototype = ApplicationArrayElement(ar_root, "prototype")
-
-        assert (isinstance(prototype, ARObject))
-        assert (isinstance(prototype, ApplicationCompositeElementDataPrototype))
-        assert (isinstance(prototype, AtpFeature))
-        assert (isinstance(prototype, AtpPrototype))
-        assert (isinstance(prototype, DataPrototype))
-        assert (isinstance(prototype, Identifiable))
-        assert (isinstance(prototype, MultilanguageReferrable))
-        assert (isinstance(prototype, Referrable))
-        assert (isinstance(prototype, ApplicationArrayElement))
-
-    def test_ApplicationRecordElement(self):
-        document = AUTOSAR.getInstance()
-        ar_root = document.createARPackage("AUTOSAR")
-        prototype = ApplicationRecordElement(ar_root, "prototype")
-
-        assert (isinstance(prototype, ARObject))
-        assert (isinstance(prototype, ApplicationCompositeElementDataPrototype))
-        assert (isinstance(prototype, AtpFeature))
-        assert (isinstance(prototype, AtpPrototype))
-        assert (isinstance(prototype, DataPrototype))
-        assert (isinstance(prototype, Identifiable))
-        assert (isinstance(prototype, MultilanguageReferrable))
-        assert (isinstance(prototype, Referrable))
-        assert (isinstance(prototype, ApplicationRecordElement))
-
-        assert (prototype.isOptional is None)

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)