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

armodel/tests/test_armodel/models/test_ar_package.py

@@ -0,0 +1,294 @@
+""" Test AR Package """
+import pytest
+
+from ....models.ar_package import AUTOSAR
+from ....models.datatype import ApplicationPrimitiveDataType, ApplicationRecordDataType, DataTypeMappingSet, ImplementationDataType, SwBaseType
+from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, Referrable
+from ....models.m2_msr import CompuMethod
+from ....models.port_interface import ClientServerInterface, DataInterface, PortInterface, SenderReceiverInterface
+from ....models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, ServiceSwComponentType, SwComponentType
+
+class TestAUTOSAR:
+
+    def test_autosar_singleton_exception(self):
+        AUTOSAR.getInstance()
+        with pytest.raises(Exception) as err:
+            AUTOSAR()
+        assert(str(err.value) == "The AUTOSAR is singleton!")
+
+    def test_cannot_find_element(self):
+        document = AUTOSAR.getInstance()
+        #with pytest.raises(Exception) as err:
+        #    document.find("/sw_package/not_found")
+        #assert(str(err.value) ==
+        #       "The sw_package of reference </sw_package/not_found> does not exist.")
+        assert(document.find("/sw_package/not_found") == None)
+
+    def test_autosar(self):
+        document = AUTOSAR.getInstance()
+        assert (isinstance(document, CollectableElement))
+        assert (isinstance(document, AUTOSAR))
+        assert (len(document.getARPackages()) == 0)
+        assert (document.schema_location == "")
+        assert (document.full_name == "")
+
+    def test_create_autosar_package(self):
+        document = AUTOSAR.getInstance()
+        ar_package = document.createARPackage("sw_package")
+        assert ("sw_package" == ar_package.short_name)
+        assert (len(document.getARPackages()) == 1)
+        assert (document.getARPackages()[0] == ar_package)
+
+        ar_package = document.find("/sw_package")
+        assert ("sw_package" == ar_package.short_name)
+
+        assert(isinstance(ar_package, ARObject))
+        assert(isinstance(ar_package, Identifiable))
+        assert(isinstance(ar_package, Referrable))
+        assert(isinstance(ar_package, MultilanguageReferrable))
+
+
+class TestARPackage:
+
+    def test_create_autosar_package(self):
+        document = AUTOSAR.getInstance()
+        ar_package_level1 = document.createARPackage("package_level1")
+        assert (ar_package_level1.short_name == "package_level1")
+        assert (ar_package_level1.full_name == "/package_level1")
+        assert (len(ar_package_level1.getARPackages()) == 0)
+
+        ar_find_package = document.find("/package_level1")
+        assert (ar_find_package == ar_package_level1)
+        assert (ar_find_package.short_name == 'package_level1')
+
+        ar_package_level2 = ar_package_level1.createARPackage("package_level2")
+        assert (ar_package_level2.short_name == 'package_level2')
+        assert (ar_package_level2.full_name ==
+                "/package_level1/package_level2")
+        assert (len(ar_package_level1.getARPackages()) == 1)
+        assert (ar_package_level1.getARPackages()[0] == ar_package_level2)
+
+        ar_find_package = document.find("/package_level1/package_level2")
+        assert (ar_find_package == ar_package_level2)
+        assert (ar_find_package.short_name == "package_level2")
+
+    def test_createEcuAbstractionSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createEcuAbstractionSwComponentType(
+            "ecu_abstract_sw_component")
+        assert(sw_component_type.short_name == "ecu_abstract_sw_component")
+        assert(isinstance(sw_component_type, EcuAbstractionSwComponentType))
+
+        find_component_type = document.find(
+            "/AUTOSAR/ecu_abstract_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "ecu_abstract_sw_component")
+
+    def test_createApplicationSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createApplicationSwComponentType(
+            "application_sw_component")
+        assert(sw_component_type.short_name == "application_sw_component")
+
+        assert(isinstance(sw_component_type, ARElement))
+        assert(isinstance(sw_component_type, AtomicSwComponentType))
+        assert(isinstance(sw_component_type, CollectableElement))
+        assert(isinstance(sw_component_type, Identifiable))
+        assert(isinstance(sw_component_type, MultilanguageReferrable))
+        assert(isinstance(sw_component_type, PackageableElement))
+        assert(isinstance(sw_component_type, Referrable))
+        assert(isinstance(sw_component_type, SwComponentType))
+        assert(isinstance(sw_component_type, ApplicationSwComponentType))
+
+        find_component_type = document.find(
+            "/AUTOSAR/application_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "application_sw_component")
+
+    def test_createServiceSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createServiceSwComponentType(
+            "service_sw_component")
+        assert(sw_component_type.short_name == "service_sw_component")
+
+        assert(isinstance(sw_component_type, ARElement))
+        assert(isinstance(sw_component_type, AtomicSwComponentType))
+        assert(isinstance(sw_component_type, CollectableElement))
+        assert(isinstance(sw_component_type, Identifiable))
+        assert(isinstance(sw_component_type, MultilanguageReferrable))
+        assert(isinstance(sw_component_type, PackageableElement))
+        assert(isinstance(sw_component_type, Referrable))
+        assert(isinstance(sw_component_type, SwComponentType))
+        assert(isinstance(sw_component_type, ServiceSwComponentType))
+
+        find_component_type = document.find("/AUTOSAR/service_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "service_sw_component")
+
+    def test_createCompositionSwComponentType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        sw_component_type = ar_root.createCompositionSwComponentType(
+            "composition_sw_component")
+        assert(sw_component_type.short_name == "composition_sw_component")
+
+        assert(isinstance(sw_component_type, ARElement))
+        assert(isinstance(sw_component_type, CollectableElement))
+        assert(isinstance(sw_component_type, Identifiable))
+        assert(isinstance(sw_component_type, MultilanguageReferrable))
+        assert(isinstance(sw_component_type, PackageableElement))
+        assert(isinstance(sw_component_type, Referrable))
+        assert(isinstance(sw_component_type, SwComponentType))
+        assert(isinstance(sw_component_type, CompositionSwComponentType))
+
+        find_component_type = document.find(
+            "/AUTOSAR/composition_sw_component")
+        assert (find_component_type == sw_component_type)
+        assert (find_component_type.short_name == "composition_sw_component")
+
+    def test_createSenderReceiverInterface(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        instance_if = ar_root.createSenderReceiverInterface(
+            "sender_receiver_interface")
+        assert(instance_if.short_name == "sender_receiver_interface")
+
+        assert(isinstance(instance_if, ARElement))
+        assert(isinstance(instance_if, CollectableElement))
+        assert(isinstance(instance_if, DataInterface))
+        assert(isinstance(instance_if, Identifiable))
+        assert(isinstance(instance_if, MultilanguageReferrable))
+        assert(isinstance(instance_if, PackageableElement))
+        assert(isinstance(instance_if, PortInterface))
+        assert(isinstance(instance_if, Referrable))
+        assert(isinstance(instance_if, SenderReceiverInterface))
+
+        find_component = document.find("/AUTOSAR/sender_receiver_interface")
+        assert (find_component == instance_if)
+        assert (find_component.short_name == "sender_receiver_interface")
+
+        assert (len(ar_root.getSenderReceiverInterfaces()) == 1)
+        assert (ar_root.getSenderReceiverInterfaces()[0] == instance_if)
+        assert (ar_root.getSenderReceiverInterfaces()[
+                0].short_name == "sender_receiver_interface")
+
+    def test_createClientServerInterface(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        instance_if = ar_root.createClientServerInterface(
+            "client_server_interface")
+        assert(instance_if.short_name == "client_server_interface")
+        assert(isinstance(instance_if, ClientServerInterface))
+
+        find_component = document.find("/AUTOSAR/client_server_interface")
+        assert (find_component == instance_if)
+        assert (find_component.short_name == "client_server_interface")
+
+        assert (len(ar_root.getClientServerInterfaces()) == 1)
+        assert (ar_root.getClientServerInterfaces()[0] == instance_if)
+        assert (ar_root.getClientServerInterfaces()[
+                0].short_name == "client_server_interface")
+
+    def test_createApplicationPrimitiveDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createApplicationPrimitiveDataType(
+            "application_primitive_data_type")
+        assert(data_type.short_name == "application_primitive_data_type")
+        assert(isinstance(data_type, ApplicationPrimitiveDataType))
+
+        find_component = document.find(
+            "/AUTOSAR/application_primitive_data_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "application_primitive_data_type")
+
+        assert (len(ar_root.getApplicationPrimitiveDataTypes()) == 1)
+        assert (ar_root.getApplicationPrimitiveDataTypes()[0] == data_type)
+        assert (ar_root.getApplicationPrimitiveDataTypes()[
+                0].short_name == "application_primitive_data_type")
+
+    def test_createApplicationRecordDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createApplicationRecordDataType(
+            "application_record_data_type")
+        assert(data_type.short_name == "application_record_data_type")
+        assert(isinstance(data_type, ApplicationRecordDataType))
+
+        find_component = document.find("/AUTOSAR/application_record_data_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "application_record_data_type")
+
+    def test_createImplementationDataType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createImplementationDataType(
+            "implementation_data_type")
+        assert(data_type.short_name == "implementation_data_type")
+        assert(isinstance(data_type, ImplementationDataType))
+
+        find_component = document.find("/AUTOSAR/implementation_data_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "implementation_data_type")
+
+        assert (len(ar_root.getImplementationDataTypes()) == 1)
+        assert (ar_root.getImplementationDataTypes()[0] == data_type)
+        assert (ar_root.getImplementationDataTypes()[
+                0].short_name == "implementation_data_type")
+
+    def test_createSwBaseType(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        data_type = ar_root.createSwBaseType("sw_base_type")
+        assert(data_type.short_name == "sw_base_type")
+        assert(isinstance(data_type, SwBaseType))
+
+        find_component = document.find("/AUTOSAR/sw_base_type")
+        assert (find_component == data_type)
+        assert (find_component.short_name == "sw_base_type")
+
+        assert (len(ar_root.getSwBaseTypes()) == 1)
+        assert (ar_root.getSwBaseTypes()[0] == data_type)
+        assert (ar_root.getSwBaseTypes()[0].short_name == "sw_base_type")
+
+    def test_createDataTypeMappingSet(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        mapping_set = ar_root.createDataTypeMappingSet("data_type_mapping_set")
+        assert(mapping_set.short_name == "data_type_mapping_set")
+        assert(isinstance(mapping_set, DataTypeMappingSet))
+
+        find_component = document.find("/AUTOSAR/data_type_mapping_set")
+        assert (find_component == mapping_set)
+        assert (find_component.short_name == "data_type_mapping_set")
+
+        assert (len(ar_root.getDataTypeMappingSets()) == 1)
+        assert (ar_root.getDataTypeMappingSets()[0] == mapping_set)
+        assert (ar_root.getDataTypeMappingSets()[
+                0].short_name == "data_type_mapping_set")
+
+    def test_createCompuMethod(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        compu_method = ar_root.createCompuMethod("compu_method")
+        assert(compu_method.short_name == "compu_method")
+        assert(isinstance(compu_method, CompuMethod))
+
+        find_component = document.find("/AUTOSAR/compu_method")
+        assert (find_component == compu_method)
+        assert (find_component.short_name == "compu_method")
+
+        assert (len(ar_root.getCompuMethods()) == 1)
+        assert (ar_root.getCompuMethods()[0] == compu_method)
+        assert (ar_root.getCompuMethods()[0].short_name == "compu_method")
+
+    def test_getSwComponentTypes(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+
+        assert (len(ar_root.getSwComponentTypes()) == 4)
+        assert (len(ar_root.getAtomicSwComponentTypes()) == 3)
+        assert (len(ar_root.getCompositionSwComponentTypes()) == 1)

armodel/tests/test_armodel/models/test_ar_ref.py

@@ -0,0 +1,74 @@
+""" Test ARRef """
+
+import pytest
+
+from ....models.ar_ref import ArVariableInImplementationDataInstanceRef, AutosarVariableRef, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
+from ....models.ar_ref import OperationInAtomicSwcInstanceRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, RefType, TRefType, AtpInstanceRef
+from ....models.general_structure import ARObject
+
+
+class TestARRef:
+    def test_RefType(self):
+        ref_type = RefType()
+        assert(ref_type.value == "")
+        assert(ref_type.dest == "")
+
+    def test_TRefType(self):
+        ref_type = TRefType()
+        assert(ref_type.value == "")
+        assert(ref_type.dest == "")
+
+    def test_AutosarVariableRef(self):
+        ref_type = AutosarVariableRef()
+        assert(ref_type != None)
+        assert(ref_type.autosar_variable_iref == None)
+        assert(ref_type.autosar_variable_in_impl_datatype == None)
+        assert(ref_type.local_variable_ref == None)
+
+    def test_AtpInstanceRef(self):
+        with pytest.raises(NotImplementedError) as err:
+            ref_type = AtpInstanceRef()
+        assert(str(err.value) == "AtpInstanceRef is an abstract class.")
+
+    def test_ProvidedPortPrototypeInstanceRef(self):
+        ref_type = PPortInCompositionInstanceRef()
+        assert(ref_type != None)
+        assert(ref_type.context_component_ref == None)
+        assert(ref_type.target_p_port_ref == None)
+
+    def test_RequiredPortPrototypeInstanceRef(self):
+        ref_type = RPortInCompositionInstanceRef()
+        assert(ref_type != None)
+        assert(ref_type.context_component_ref == None)
+        assert(ref_type.target_r_port_ref == None)
+
+    def test_ArVariableInImplementationDataInstanceRef(self):
+        ref_type = ArVariableInImplementationDataInstanceRef()
+        assert(ref_type != None)
+        assert(ref_type.port_prototype_ref == None)
+        assert(ref_type.target_data_prototype_ref == None)
+
+    def test_OperationInAtomicSwcInstanceRef(self):
+        with pytest.raises(NotImplementedError) as err:
+            ref_type = OperationInAtomicSwcInstanceRef()
+        assert(str(err.value) == "OperationInAtomicSwcInstanceRef is an abstract class.")
+
+    def test_POperationInAtomicSwcInstanceRef(self):
+        ref_type = POperationInAtomicSwcInstanceRef()
+        assert(isinstance(ref_type, ARObject))
+        assert(isinstance(ref_type, AtpInstanceRef))
+        assert(isinstance(ref_type, OperationInAtomicSwcInstanceRef))
+        assert(isinstance(ref_type, POperationInAtomicSwcInstanceRef))
+        assert(ref_type != None)
+        assert(ref_type.context_p_port_ref == None)
+        assert(ref_type.target_provided_operation_ref == None)
+
+    def test_ROperationInAtomicSwcInstanceRef(self):
+        ref_type = ROperationInAtomicSwcInstanceRef()
+        assert(isinstance(ref_type, ARObject))
+        assert(isinstance(ref_type, AtpInstanceRef))
+        assert(isinstance(ref_type, OperationInAtomicSwcInstanceRef))
+        assert(isinstance(ref_type, ROperationInAtomicSwcInstanceRef))
+        assert(ref_type != None)
+        assert(ref_type.context_r_port_ref == None)
+        assert(ref_type.target_required_operation_ref == None)

armodel/tests/test_armodel/models/test_bsw_module_template.py

@@ -0,0 +1,46 @@
+import pytest
+
+from ....models.bsw_module_template import BswModuleDescription, BswModuleEntry, BswModuleEntity, BswCalledEntity
+from .... import AUTOSAR
+
+class TestBswModuleDescription:
+    def test_construct(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        bsw_module_description = BswModuleDescription(ar_root, "bsw_module")
+        assert(bsw_module_description != None)
+        assert(bsw_module_description.short_name == "bsw_module")
+
+    def test_category(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        bsw_module_description = BswModuleDescription(ar_root, "bsw_module")
+        with pytest.raises(ValueError) as err:
+            bsw_module_description.category = "invalid"
+        assert(str(err.value) == "Invalid category <invalid> of BswModuleDescription <bsw_module>")
+
+        bsw_module_description.category = "BSW_MODULE"
+        assert(bsw_module_description.category == "BSW_MODULE")
+
+class Test_M2_AUTOSARTemplates_BswModuleTemplate_BswInterfaces:
+    def test_BswModuleEntry(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        entry = BswModuleEntry(ar_root, "bsw_entry")
+        assert(entry != None)
+        assert(entry.short_name == "bsw_entry")
+ 
+class Test_M2_AUTOSARTemplates_BswModuleTemplate_BswBehavior:
+    def test_BswModuleEntity(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        with pytest.raises(NotImplementedError) as err:
+            BswModuleEntity(ar_root, "BswModuleEntity")
+        assert(str(err.value) == "BswModuleEntity is an abstract class.")
+
+    def test_BswCalledEntity(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        entity = BswCalledEntity(ar_root, "bsw_called_entity")
+        assert(entity != None)
+        assert(entity.short_name == "bsw_called_entity")

armodel/tests/test_armodel/models/test_common_structure.py

@@ -0,0 +1,73 @@
+import pytest
+
+from .... import AUTOSAR
+from ....models.common_structure import AbstractImplementationDataTypeElement, ConstantReference, ImplementationDataTypeElement, ValueSpecification, ConstantSpecification, ExecutableEntity
+from ....models.datatype import AbstractImplementationDataType
+from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable
+from ....models.general_structure import MultilanguageReferrable, PackageableElement, Referrable
+
+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.")
+
+    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)) 
+
+    def test_ConstantReference(self):
+        ref = ConstantReference()
+
+        assert(ref.constant_ref == None)
+
+        assert(isinstance(ref, ARObject))
+        assert(isinstance(ref, ValueSpecification))
+        assert(isinstance(ref, ConstantReference))
+
+class Test_M2_AUTOSARTemplates_CommonStructure_InternalBehavior:
+    def test_ExecutableEntity(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        with pytest.raises(NotImplementedError) as err:
+            ExecutableEntity(ar_root, "ExecutableEntity")
+        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")
+
+        assert(data_type.short_name == "implementation_data_type")
+        assert(data_type.arraySize == None)
+        assert(data_type.isOptional == None)
+
+        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))
+
+        sub_type = data_type.createImplementationDataTypeElement("sub_type")
+        assert(sub_type.short_name == "sub_type")
+        assert(isinstance(sub_type, ImplementationDataTypeElement))
+
+        assert(len(data_type.getImplementationDataTypeElements()) == 1)
+        sub_type2 = data_type.getImplementationDataTypeElements()[0]
+        assert(sub_type == sub_type2) 

armodel/tests/test_armodel/models/test_data_dictionary.py

@@ -0,0 +1,29 @@
+import pytest
+
+from ....models.data_dictionary import SwDataDefProps, SwPointerTargetProps
+from ....models.general_structure 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 == None)
+        assert(props.compuMethodRef == None)
+        assert(props.dataConstrRef == None)                 
+        assert(props.implementationDataTypeRef == None)
+        assert(props.swImplPolicy == None)
+        assert(props.swCalibrationAccess == None)
+        assert(props.sw_pointer_target_props == None)
+
+    def test_SwPointerTargetProps(self):
+        props = SwPointerTargetProps()
+
+        assert(isinstance(props, ARObject))
+        assert(isinstance(props, SwPointerTargetProps))
+
+        assert(props.function_pointer_signature == None)
+        assert(props.sw_data_def_props == None)
+        assert(props.target_category == None)

armodel/tests/test_armodel/models/test_data_prototype.py

@@ -0,0 +1,86 @@
+import pytest
+
+from .... import AUTOSAR
+from ....models.ar_ref import RefType
+from ....models.data_prototype import ApplicationArrayElement, ApplicationCompositeElementDataPrototype, ApplicationRecordElement, AtpPrototype, AutosarDataPrototype, DataPrototype, VariableDataPrototype
+from ....models.general_structure import ARObject, AtpFeature, Identifiable, MultilanguageReferrable, Referrable
+
+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.type_tref 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 == None)