py-eb-model 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

eb_model/reporter/excel_reporter/nvm_xdm.py

@@ -1,30 +1,91 @@
 from ...models.eb_doc import EBModel
+from ...models.nvm_xdm import NvMEaRef, NvMFeeRef
 from ...reporter.excel_reporter.abstract import ExcelReporter
+from openpyxl.styles.alignment import Alignment
 
 
 class NvMXdmXlsWriter(ExcelReporter):
     def __init__(self) -> None:
         super().__init__()
 
+    def write_nvm_general(self, doc: EBModel):
+        sheet = self.wb.create_sheet("General", 0)
+
+        title_row = ["Key", "Value"]
+        self.write_title_row(sheet, title_row)
+
+        nvm_common = doc.getNvM().getNvMCommon()
+
+        if nvm_common is None:
+            self.logger.error("NvMCommon is Invalid and General updating is skipped.")
+            return
+
+        row = 2
+        self.write_cell(sheet, row, 1, "NvMCompiledConfigId")
+        self.write_cell_center(sheet, row, 2, nvm_common.getNvMCompiledConfigId())
+        row += 1
+        self.write_cell(sheet, row, 1, "NvMDatasetSelectionBits")
+        self.write_cell_center(sheet, row, 2, nvm_common.getNvMDatasetSelectionBits())
+        row += 1
+        self.write_cell(sheet, row, 1, "NvMMaxNumOfReadRetries")
+        self.write_cell_center(sheet, row, 2, "3")
+        row += 1
+        self.write_cell(sheet, row, 1, "NvMMaxNumOfWriteRetries")
+        self.write_cell_center(sheet, row, 2, "3")
+        row += 1
+
+        self.auto_width(sheet)
+
     def write_nvm_block_descriptors(self, doc: EBModel):
-        sheet = self.wb.create_sheet("NvMBlock", 0)
+        sheet = self.wb.create_sheet("Block List", 2)
 
         title_row = [
             "BlockId", "Name", "NvMBlockEcucPartitionRef", "NvMRamBlockDataAddress", "NvMRomBlockDataAddress",
-            "NvMBlockManagementType", "NvMNvBlockLength", "NvMNvBlockNum", "NvMSelectBlockForReadAll", "NvMSelectBlockForWriteAll"]
+            "NvMBlockJobPriority", "NvMResistantToChangedSw", "NvMBlockManagementType", "NvMNvBlockLength", "NvMBlockCrcType",
+            "NvMNvBlockNum", "NvMSelectBlockForReadAll", "NvMSelectBlockForWriteAll", "NvMProvideRteJobFinishedPort", "NvMProvideRteServicePort",
+            "NvMInitBlockCallbackFnc", "NvMSingleBlockCallbackFnc", "NvMReadRamBlockFromNvCallback", "NvMWriteRamBlockToNvCallback", "NvMBlockUseSyncMechanism",  # noqa E501
+            "NvMNvBlockBaseNumber", "NvMFeeRef"]
         self.write_title_row(sheet, title_row)
 
         row = 2
         for nvm_block in doc.getNvM().getNvMBlockDescriptorList():
-            self.write_cell(sheet, row, 1, nvm_block.getNvMNvramBlockIdentifier())
+            self.write_cell_center(sheet, row, 1, nvm_block.getNvMNvramBlockIdentifier())
             self.write_cell(sheet, row, 2, nvm_block.getName())
-            self.write_cell(sheet, row, 3, nvm_block.getNvMBlockEcucPartitionRef())
+            if nvm_block.getNvMBlockEcucPartitionRef() is not None:
+                self.write_cell_center(sheet, row, 3, nvm_block.getNvMBlockEcucPartitionRef().getShortName())
             self.write_cell(sheet, row, 4, nvm_block.getNvMRamBlockDataAddress())
             self.write_cell(sheet, row, 5, nvm_block.getNvMRomBlockDataAddress())
-            self.write_cell(sheet, row, 6, nvm_block.getNvMBlockManagementType())
-            self.write_cell(sheet, row, 7, nvm_block.getNvMNvBlockLength())
-            self.write_cell(sheet, row, 8, nvm_block.getNvMNvBlockNum())
 
+            self.write_cell_center(sheet, row, 6, nvm_block.getNvMBlockJobPriority())
+            self.write_bool_cell(sheet, row, 7, nvm_block.getNvMResistantToChangedSw())
+            self.write_cell_center(sheet, row, 8, nvm_block.getNvMBlockManagementType())
+            self.write_cell_center(sheet, row, 9, nvm_block.getNvMNvBlockLength())
+            if nvm_block.getNvMBlockUseCrc():
+                self.write_cell_center(sheet, row, 10, nvm_block.getNvMBlockCrcType())
+
+            self.write_cell(sheet, row, 11, nvm_block.getNvMNvBlockNum())
+            self.write_bool_cell(sheet, row, 12, nvm_block.getNvMSelectBlockForReadAll())
+            self.write_bool_cell(sheet, row, 13, nvm_block.getNvMSelectBlockForWriteAll())
+            self.write_bool_cell(sheet, row, 14, nvm_block.getNvMProvideRteJobFinishedPort())
+            self.write_bool_cell(sheet, row, 15, nvm_block.getNvMProvideRteServicePort())
+
+            if nvm_block.getNvMInitBlockCallback() is not None:
+                self.write_cell(sheet, row, 16, nvm_block.getNvMInitBlockCallback().getNvMInitBlockCallbackFnc())
+            if nvm_block.getNvMSingleBlockCallback() is not None:
+                self.write_cell(sheet, row, 17, nvm_block.getNvMSingleBlockCallback().getNvMSingleBlockCallbackFnc())
+            if nvm_block.getNvMReadRamBlockFromNvCallback() is not None:
+                self.write_cell(sheet, row, 18, nvm_block.getNvMReadRamBlockFromNvCallback())
+            if nvm_block.getNvMWriteRamBlockToNvCallback() is not None:
+                self.write_cell(sheet, row, 19, nvm_block.getNvMWriteRamBlockToNvCallback())
+            self.write_bool_cell(sheet, row, 20, nvm_block.getNvMBlockUseSyncMechanism())
+            
+            self.write_cell_center(sheet, row, 21, nvm_block.getNvMNvBlockBaseNumber())
+            block_reference = nvm_block.getNvMTargetBlockReference()
+            if block_reference is not None:
+                if isinstance(block_reference, NvMFeeRef):
+                    self.write_cell(sheet, row, 22, block_reference.getNvMNameOfFeeBlock().getShortName())
+                else:
+                    raise NotImplementedError("Unsupported Target block reference.")
             
             row += 1
 
@@ -32,9 +93,38 @@ class NvMXdmXlsWriter(ExcelReporter):
 
         self.auto_width(sheet)
 
+    def write_nvm_bsw_distribution(self, doc: EBModel):
+        sheet = self.wb.create_sheet("BSW Distribution", 1)
+
+        title_row = ["NvMEcucPartitionRef", "Master"]
+        self.write_title_row(sheet, title_row)
+
+        nvm_common = doc.getNvM().getNvMCommon()
+
+        if nvm_common is None:
+            self.logger.error("NvMCommon is Invalid and BSW Distribution updating is skipped.")
+            return
+        
+        master_partition_ref = nvm_common.getNvMMasterEcucPartitionRef()
+
+        row = 2
+        for ref_link in nvm_common.getNvMEcucPartitionRefList():
+            self.write_cell(sheet, row, 1, ref_link.getShortName())
+            if ref_link.getShortName() == master_partition_ref.getShortName():
+                self.write_cell(sheet, row, 2, "Y", format={"alignment": Alignment(horizontal="center")})
+            else:
+                self.write_cell(sheet, row, 2, "N", format={"alignment": Alignment(horizontal="center")})
+            row += 1
+
+            self.logger.debug("Write NvM EcucPartition <%s>" % ref_link.getShortName())
+
+        self.auto_width(sheet)
+
     def write(self, filename, doc: EBModel, options):
         self.logger.info("Writing <%s>" % filename)
 
+        self.write_nvm_general(doc)
+        self.write_nvm_bsw_distribution(doc)
         self.write_nvm_block_descriptors(doc)
 
         self.save(filename)

eb_model/reporter/excel_reporter/os_xdm.py

@@ -49,24 +49,37 @@ class OsXdmXlsWriter(ExcelReporter):
     def write_os_isrs(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsIsr", 1)
 
-        title_row = ["Name", "OsApplication", "OsIsrCategory", "OsStacksize", "OsIsrPriority", "OsIsrVector"]
+        title_row = [
+            "Name", "OsApplication", "OsIsrCategory", "OsStacksize", "OsIsrPriority",
+            "OsIsrVector", "MkMemoryRegion"]
         self.write_title_row(sheet, title_row)
 
         row = 2
         for os_isr in doc.getOs().getOsIsrList():
-            self.write_cell(sheet, row, 1, os_isr.getName())
+            self.write_cell(sheet, row, 1, os_isr.getName(), {'alignment': Alignment(vertical="top")})
             os_app = doc.getOs().getOsIsrOsApplication(os_isr.getName())
             if os_app is not None:
-                self.write_cell(sheet, row, 2, os_app.getName())
-            self.write_cell(sheet, row, 3, os_isr.getOsIsrCategory())
-            self.write_cell(sheet, row, 4, os_isr.getOsStacksize())
-            self.write_cell(sheet, row, 5, os_isr.getOsIsrPriority())
-            self.write_cell(sheet, row, 6, os_isr.getOsIsrVector())
+                self.write_cell(sheet, row, 2, os_app.getName(),
+                                format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 3, os_isr.getOsIsrCategory(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 4, os_isr.getOsStacksize(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 5, os_isr.getOsIsrPriority(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 6, os_isr.getOsIsrVector(),
+                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+            if len(os_isr.getOsIsrMkMemoryRegionRefs()) > 1:
+                self.write_cell(sheet, row, 7, "\n".join(map(lambda a: a.getShortName(), os_isr.getOsIsrMkMemoryRegionRefs())),
+                                {'alignment': Alignment(wrapText=True, vertical="top")})
+            else:
+                self.write_cell(sheet, row, 7, "\n".join(map(lambda a: a.getShortName(), os_isr.getOsIsrMkMemoryRegionRefs())),
+                                {'alignment': Alignment(vertical="top")})
             row += 1
 
             self.logger.debug("Write OsIsr <%s>" % os_isr.getName())
 
-        self.auto_width(sheet)
+        self.auto_width(sheet, {"G": 25})
 
     def write_os_schedule_tables(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsScheduleTable", 2)
@@ -77,9 +90,12 @@ class OsXdmXlsWriter(ExcelReporter):
         row = 2
         for os_schedule_table in doc.getOs().getOsScheduleTableList():
             self.write_cell(sheet, row, 1, os_schedule_table.getName())
-            self.write_cell(sheet, row, 2, os_schedule_table.getOsScheduleTableDuration())
-            self.write_cell(sheet, row, 3, os_schedule_table.getOsScheduleTableRepeating())
-            self.write_cell(sheet, row, 4, os_schedule_table.getOsScheduleTableCounterRef().getShortName())
+            self.write_cell(sheet, row, 2, os_schedule_table.getOsScheduleTableDuration(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 3, os_schedule_table.getOsScheduleTableRepeating(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 4, os_schedule_table.getOsScheduleTableCounterRef().getShortName(),
+                            format={'alignment': Alignment(horizontal="center")})
             row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % os_schedule_table.getName())
@@ -95,11 +111,16 @@ class OsXdmXlsWriter(ExcelReporter):
         row = 2
         for os_counter in doc.getOs().getOsCounterList():
             self.write_cell(sheet, row, 1, os_counter.getName())
-            self.write_cell(sheet, row, 2, os_counter.getOsCounterMaxAllowedValue())
-            self.write_cell(sheet, row, 3, os_counter.getOsCounterMinCycle())
-            self.write_cell(sheet, row, 4, os_counter.getOsCounterTicksPerBase())
-            self.write_cell(sheet, row, 5, os_counter.getOsCounterType())
-            self.write_cell(sheet, row, 6, os_counter.getOsSecondsPerTick())
+            self.write_cell(sheet, row, 2, os_counter.getOsCounterMaxAllowedValue(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 3, os_counter.getOsCounterMinCycle(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 4, os_counter.getOsCounterTicksPerBase(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 5, os_counter.getOsCounterType(),
+                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell(sheet, row, 6, os_counter.getOsSecondsPerTick(),
+                            format={'alignment': Alignment(horizontal="center")})
             row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % os_counter.getName())
@@ -109,7 +130,7 @@ class OsXdmXlsWriter(ExcelReporter):
     def write_expiry_points(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsScheduleTableExpiryPoint", 4)
 
-        title_row = ["ExpiryPoint", "OsScheduleTable", "OsCounter" "Offset (ms)", "Task"]
+        title_row = ["ExpiryPoint", "OsScheduleTable", "OsCounter", "Offset (ms)", "Task"]
         self.write_title_row(sheet, title_row)
 
         row = 2
@@ -119,15 +140,77 @@ class OsXdmXlsWriter(ExcelReporter):
             for expiry_point in expiry_point_list:
                 self.write_cell(sheet, row, 1, expiry_point.getName())
                 self.write_cell(sheet, row, 2, table.getName())
-                self.write_cell(sheet, row, 3, table.getOsScheduleTableCounterRef().getShortName())
-                self.write_cell(sheet, row, 4, expiry_point.getOsScheduleTblExpPointOffset())
-                self.write_cell(sheet, row, 5, len(expiry_point.getOsScheduleTableTaskActivationList()))
+                self.write_cell(sheet, row, 3, table.getOsScheduleTableCounterRef().getShortName(),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 4, expiry_point.getOsScheduleTblExpPointOffset(),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 5, len(expiry_point.getOsScheduleTableTaskActivationList()),
+                                format={'alignment': Alignment(horizontal="center")})
                 row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % table.getName())
 
         self.auto_width(sheet)
 
+    def mk_memory_region_exists(self, doc: EBModel) -> bool:
+        mk = doc.getOs().getOsMicrokernel()
+        if mk is None:
+            return False
+        
+        protection = mk.getMkMemoryProtection()
+        if protection is None:
+            return False
+        
+        if len(protection.getMkMemoryRegionList()) <= 0:
+            return False
+        
+        return True
+    
+    def write_mk_memory_regions(self, doc: EBModel):
+        if self.mk_memory_region_exists(doc) is True:
+            sheet = self.wb.create_sheet("MkMemoryRegion", 5)
+
+            title_row = [
+                "Name", "Flags", "Initialize", "Global", "InitThread",
+                "IdleThread", "OsThread", "ErrorHook", "ProtHook", "ShutdownHook",
+                "Shutdown", "Kernel", "InitializePerCore"
+            ]
+            self.write_title_row(sheet, title_row)
+
+            row = 2
+            for region in doc.getOs().getOsMicrokernel().getMkMemoryProtection().getMkMemoryRegionList():
+                self.write_cell(sheet, row, 1, region.getName())
+                self.write_cell(sheet, row, 2, region.getMkMemoryRegionFlags(),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 3, self.format_boolean(region.getMkMemoryRegionInitialize()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 4, self.format_boolean(region.getMkMemoryRegionGlobal()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 5, self.format_boolean(region.getMkMemoryRegionInitThreadAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 6, self.format_boolean(region.getMkMemoryRegionIdleThreadAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 7, self.format_boolean(region.getMkMemoryRegionOsThreadAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 8, self.format_boolean(region.getMkMemoryRegionErrorHookAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 9, self.format_boolean(region.getMkMemoryRegionProtHookAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 10, self.format_boolean(region.getMkMemoryRegionShutdownHookAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 11, self.format_boolean(region.getMkMemoryRegionShutdownAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 12, self.format_boolean(region.getMkMemoryRegionKernelAccess()),
+                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell(sheet, row, 13, self.format_boolean(region.getMkMemoryRegionInitializePerCore()),
+                                format={'alignment': Alignment(horizontal="center")})
+
+                row += 1
+
+                self.logger.debug("Write MkMemoryRegion <%s>" % region.getName())
+
+            self.auto_width(sheet, {"B": 15})
+
     def write(self, filename, doc: EBModel, options={"skip_os_task": False}):
         self.logger.info("Writing <%s>" % filename)
 
@@ -137,5 +220,6 @@ class OsXdmXlsWriter(ExcelReporter):
         self.write_os_schedule_tables(doc)
         self.write_os_counters(doc)
         self.write_expiry_points(doc)
+        self.write_mk_memory_regions(doc)
 
         self.save(filename)

eb_model/reporter/excel_reporter/rte_xdm.py

@@ -1,4 +1,5 @@
-from ...models.rte_xdm import RteBswEventToTaskMapping, RteBswModuleInstance, RteEventToTaskMapping, RteSwComponentInstance
+from ...models.rte_xdm import RteBswEventToTaskMapping, RteBswEventToTaskMappingV3, RteBswEventToTaskMappingV4, RteBswModuleInstance
+from ...models.rte_xdm import RteEventToTaskMapping, RteEventToTaskMappingV3, RteEventToTaskMappingV4, RteSwComponentInstance
 from ...models.eb_doc import EBModel
 from .abstract import ExcelReporter
 
@@ -59,19 +60,29 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
 
         row = 2
         for os_task, mappings in doc.getRte().getMappedEvents().items():
-            for mapping in sorted(mappings, key=lambda a: a.getRtePositionInTask()):
+            for mapping in sorted(mappings, key=lambda a: a.getRtePositionInTaskNumber()):
                 self.write_cell(sheet, row, 1, os_task)
                 if isinstance(mapping, RteBswEventToTaskMapping):
                     self.logger.debug("Write Mapping %s" % mapping.getName())
                     instance = mapping.getRteBswModuleInstance()
-                    self.write_cell(sheet, row, 2, mapping.getRteBswEventRefs().getShortName())
+                    if isinstance(mapping, RteBswEventToTaskMappingV3):
+                        self.write_cell(sheet, row, 2, mapping.getRteBswEventRef().getShortName())
+                    elif isinstance(mapping, RteBswEventToTaskMappingV4):
+                        self.write_cell(sheet, row, 2, " ".join(map(lambda i: i.getShortName(), mapping.getRteBswEventRefs())))
+                    else:
+                        raise NotImplementedError("Unsupported RteEventToTaskMapping")
                     self.write_cell(sheet, row, 5, instance.getRteBswImplementationRef().getValue())
                     self.write_cell(sheet, row, 6, mapping.getRteBswPositionInTask())
                     self.write_cell(sheet, row, 7, mapping.getRteBswActivationOffset())
                 elif isinstance(mapping, RteEventToTaskMapping):
                     self.logger.debug("Write Mapping %s" % mapping.getName())
                     instance = mapping.getRteSwComponentInstance()
-                    self.write_cell(sheet, row, 2, mapping.getRteEventRef().getShortName())
+                    if isinstance(mapping, RteEventToTaskMappingV3):
+                        self.write_cell(sheet, row, 2, mapping.getRteEventRef().getShortName())
+                    elif instance(mapping, RteEventToTaskMappingV4):
+                        self.write_cell(sheet, row, 2, " ".join(map(lambda i: i.getShortName(), mapping.getRteEventRefs())))
+                    else:
+                        raise NotImplementedError("Unsupported RteEventToTaskMapping")
                     self.write_cell(sheet, row, 5, instance.getRteSoftwareComponentInstanceRef().getValue())
                     self.write_cell(sheet, row, 6, mapping.getRtePositionInTask())
                     self.write_cell(sheet, row, 7, mapping.getRteActivationOffset())

eb_model/tests/models/test_abstract.py

@@ -0,0 +1,201 @@
+import pytest
+from ...models.abstract import Module, EcucParamConfContainerDef, Version, EcucRefType, EcucObject, EcucEnumerationParamDef
+from ...models.eb_doc import EBModel
+
+
+class TestModule:
+
+    def test_module_initialization(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        module = Module(parent, "TestModule")
+
+        assert module.getName() == "TestModule"
+        assert module.getParent() == parent
+        assert isinstance(module.getArVersion(), Version)
+        assert isinstance(module.getSwVersion(), Version)
+
+    def test_module_ar_version(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        module = Module(parent, "TestModule")
+
+        ar_version = module.getArVersion()
+        ar_version.setMajorVersion(1).setMinorVersion(2).setPatchVersion(3)
+
+        assert ar_version.getMajorVersion() == 1
+        assert ar_version.getMinorVersion() == 2
+        assert ar_version.getPatchVersion() == 3
+
+        # Check the version string format
+        assert ar_version.getVersion() == "1.2.3"
+
+    def test_module_sw_version(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        module = Module(parent, "TestModule")
+
+        sw_version = module.getSwVersion()
+        sw_version.setMajorVersion(4).setMinorVersion(5).setPatchVersion(6)
+
+        assert sw_version.getMajorVersion() == 4
+        assert sw_version.getMinorVersion() == 5
+        assert sw_version.getPatchVersion() == 6
+
+        # Check the version string format
+        assert sw_version.getVersion() == "4.5.6"
+
+    def test_module_add_and_get_element(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        module = Module(parent, "TestModule")
+
+        element = EcucParamConfContainerDef(module, "ChildElement")
+        module.addElement(element)
+
+        assert module.getTotalElement() == 1
+        assert module.getElement("ChildElement") == element
+
+    def test_module_remove_element(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        module = Module(parent, "TestModule")
+
+        element = EcucParamConfContainerDef(module, "ChildElement")
+        module.addElement(element)
+
+        assert module.getTotalElement() == 1
+
+        module.removeElement("ChildElement")
+        assert module.getTotalElement() == 0
+        assert module.getElement("ChildElement") is None
+
+    def test_module_get_full_name(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        module = Module(parent, "TestModule")
+
+        assert module.getFullName() == "/Parent/TestModule"
+
+
+class TestEcucRefType:
+
+    def test_initialization(self):
+        ref = EcucRefType("/Parent/Child")
+        assert ref.getValue() == "/Parent/Child"
+
+    def test_set_value(self):
+        ref = EcucRefType("/Parent/Child")
+        ref.setValue("/NewParent/NewChild")
+        assert ref.getValue() == "/NewParent/NewChild"
+
+    def test_str_representation(self):
+        ref = EcucRefType("/Parent/Child")
+        assert str(ref) == "/Parent/Child"
+
+    def test_get_short_name_valid(self):
+        ref = EcucRefType("/Parent/Child")
+        assert ref.getShortName() == "Child"
+
+    def test_get_short_name_invalid(self):
+        ref = EcucRefType("InvalidValue")
+        assert ref.getShortName() == "InvalidValue"
+
+    def test_get_short_name_raises_error_on_none(self):
+        ref = EcucRefType(None)
+        with pytest.raises(ValueError, match="Invalid value of EcucRefType"):
+            ref.getShortName()
+
+
+class TestEcucParamConfContainerDef:
+
+    def test_initialization(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "TestContainer")
+
+        assert container.getName() == "TestContainer"
+        assert container.getParent() == root
+        assert container.getTotalElement() == 0
+
+    def test_add_element(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "TestContainer")
+        child = EcucParamConfContainerDef(container, "ChildElement")
+
+        container.addElement(child)
+
+        assert container.getTotalElement() == 1
+        assert container.getElement("ChildElement") == child
+
+    def test_remove_element(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "TestContainer")
+        child = EcucParamConfContainerDef(container, "ChildElement")
+
+        container.addElement(child)
+        assert container.getTotalElement() == 1
+
+        container.removeElement("ChildElement")
+        assert container.getTotalElement() == 0
+        assert container.getElement("ChildElement") is None
+
+    def test_remove_element_invalid_key(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "TestContainer")
+
+        with pytest.raises(KeyError, match="Invalid key <InvalidKey> for removing element"):
+            container.removeElement("InvalidKey")
+
+    def test_get_element_list(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "TestContainer")
+        child1 = EcucParamConfContainerDef(container, "Child1")
+        child2 = EcucParamConfContainerDef(container, "Child2")
+
+        container.addElement(child1)
+        container.addElement(child2)
+
+        element_list = list(container.getElementList())
+        assert len(element_list) == 2
+        assert child1 in element_list
+        assert child2 in element_list
+
+    def test_get_element_not_found(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "TestContainer")
+
+        assert container.getElement("NonExistent") is None
+
+
+class TestEcucObject:
+
+    def test_initialization_raises_error(self):
+        root = EBModel.getInstance()
+        with pytest.raises(ValueError, match="Abstract EcucObject cannot be initialized."):
+            EcucObject(root, "AbstractObject")
+
+    def test_get_and_set_name(self):
+        root = EBModel.getInstance()
+        container = EcucParamConfContainerDef(root, "Parent")
+        obj = EcucEnumerationParamDef(container, "TestObject")
+
+        assert obj.getName() == "TestObject"
+        obj.setName("NewName")
+        assert obj.getName() == "NewName"
+
+    def test_get_and_set_parent(self):
+        root = EBModel.getInstance()
+        container1 = EcucParamConfContainerDef(root, "Parent1")
+        container2 = EcucParamConfContainerDef(root, "Parent2")
+        obj = EcucEnumerationParamDef(container1, "TestObject")
+
+        assert obj.getParent() == container1
+        obj.setParent(container2)
+        assert obj.getParent() == container2
+
+    def test_get_full_name(self):
+        root = EBModel.getInstance()
+        parent = EcucParamConfContainerDef(root, "Parent")
+        obj = EcucEnumerationParamDef(parent, "Child")
+
+        assert obj.getFullName() == "/Parent/Child"

eb_model/tests/models/test_eb_doc.py

@@ -0,0 +1,66 @@
+import pytest
+from ...models.eb_doc import EBModel, PreferenceModel
+
+
+class TestEBModel:
+
+    def test_ebmodel_singleton_exception(self):
+        EBModel.getInstance()
+        with pytest.raises(Exception) as err:
+            EBModel()
+        assert (str(err.value) == "The EBModel is singleton!")
+
+    def test_cannot_find_element(self):
+        document = EBModel.getInstance()
+        assert (document.find("/os/os") is None)
+
+    def test_ebmodel(self):
+        document = EBModel.getInstance()
+        assert (isinstance(document, EBModel))
+        assert (isinstance(document, EBModel))
+        assert (document.getFullName() == "")
+
+    def test_clear(self):
+        document = EBModel.getInstance()
+        document.clear()
+        assert (document.getTotalElement() == 0)
+        document.getOs()
+        assert (document.getTotalElement() == 1)
+        document.clear()
+        assert (document.getTotalElement() == 0)
+
+    def test_ebmodel_get_os(self):
+        document = EBModel.getInstance()
+        os = document.getOs()
+        assert (os.getFullName() == "/Os/Os")
+
+    def test_ebmodel_get_rte(self):
+        document = EBModel.getInstance()
+        rte = document.getRte()
+        assert (rte.getFullName() == "/Rte/Rte")
+
+    def test_ebmodel_get_nvm(self):
+        document = EBModel.getInstance()
+        nvm = document.getNvM()
+        assert (nvm.getFullName() == "/NvM/NvM")
+
+
+class TestPreferenceModel:
+
+    def test_preference_model_singleton_exception(self):
+        PreferenceModel.getInstance()
+        with pytest.raises(Exception) as err:
+            PreferenceModel()
+        assert (str(err.value) == "The PreferenceModel is singleton!")
+
+    def test_mode_get_system_description_importer(self):
+        document = PreferenceModel.getInstance()
+        importer = document.getSystemDescriptionImporter()
+        assert importer.getFullName() == "/ImporterExporterAdditions/SystemDescriptionImporters"
+
+        importer = document.find(
+            "/ImporterExporterAdditions/SystemDescriptionImporters")
+        assert importer.getFullName() == "/ImporterExporterAdditions/SystemDescriptionImporters"
+
+        importer = document.getSystemDescriptionImporter()
+        assert importer.getFullName() == "/ImporterExporterAdditions/SystemDescriptionImporters"

eb_model/tests/models/test_eclipse_project.py

@@ -0,0 +1,21 @@
+import pytest
+from ...models.eclipse_project import Link
+
+
+class TestLink:
+
+    def test_initialization(self):
+        link = Link("TestLink", "File", "file:///path/to/resource")
+        assert link.name == "TestLink"
+        assert link.type == "File"
+        assert link.locationURI == "file:///path/to/resource"
+
+    def test_set_attributes(self):
+        link = Link("InitialName", "Folder", "file:///initial/path")
+        link.name = "UpdatedName"
+        link.type = "File"
+        link.locationURI = "file:///updated/path"
+
+        assert link.name == "UpdatedName"
+        assert link.type == "File"
+        assert link.locationURI == "file:///updated/path"