peakrdl-python 3.0.0rc6__tar.gz → 3.0.0rc8__tar.gz

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/.github/workflows/action.yaml

@@ -425,10 +425,47 @@ jobs:
         mypy autoformatted_output
         python -m unittest discover -s autoformatted_output
 
+  pathological:
+
+    needs:
+      - integration_tests
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install .[peakrdl]
+          python -m pip install mypy
+
+      - name: Prepare System RDL
+        run: |
+          mkdir ./pathological_test
+          python -m tests.pathological_register_maps.pathological_rdl_builder ./pathological_test/deep.rdl deep
+
+      - name: build_package
+        run: |
+          peakrdl python ./pathological_test/deep.rdl -o ./pathological_test/ --skip_library_copy
+
+      - name: type check generated code
+        run: |
+           mypy ./pathological_test/deep/
+
+      - name: Run unit tests
+        run: python -m unittest discover -s ./pathological_test/
+
   #-------------------------------------------------------------------------------
   build:
     needs:
       - autoformating
+      - pathological
 
     name: Build source distribution
     runs-on: ubuntu-latest

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: peakrdl-python
-Version: 3.0.0rc6
+Version: 3.0.0rc8
 Summary: Generate Python Register Access Layer (RAL) from SystemRDL
 Author: Keith Brady
 License:              GNU LESSER GENERAL PUBLIC LICENSE
@@ -191,7 +191,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9.2
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: systemrdl-compiler>=1.29.3
+Requires-Dist: systemrdl-compiler>=1.31.0
 Requires-Dist: jinja2
 Requires-Dist: typing-extensions; python_version < "3.11"
 Requires-Dist: more_itertools; python_version < "3.13"

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/docs/generated_package.rst

@@ -174,6 +174,10 @@ Legacy Block Callback and Block Access
       * ``NormalCallbackSetLegacy`` for standard python function callbacks
       * ``AsyncCallbackSetLegacy`` for async python function callbacks, these are called from the library using ``await``
 
+.. versionchanged:: 3.0.0
+
+    The ``legacy_block_access`` will now default to ``False``
+
 Legacy Enumeration Types
 ------------------------
 
@@ -187,6 +191,10 @@ Legacy Enumeration Types
    There was a small risk this may impact some users code, in the case of advanced usage of the
    enumeration. The old behaviour can be brought back using the ``legacy_enum_type`` build option.
 
+.. versionchanged:: 3.0.0
+
+    The ``legacy_enum_type`` will now default to ``False``
+
 
 Using the Register Access Layer
 ===============================

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 # Callable is broken in python 3.9.0 and 3.9.1 so these need to be excluded
 requires-python = ">=3.9.2"
 dependencies = [
-    "systemrdl-compiler>=1.29.3", # this is needed to make sure all the latest type checking
+    "systemrdl-compiler>=1.31.0", # this is needed for the latest overlappign register features
     "jinja2",
     "typing-extensions;python_version<'3.11'",
     # the batched fucntion was adopted into the standard python library at 3.13

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/src/peakrdl_python/__about__.py

@@ -17,4 +17,4 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Variables that describes the peakrdl-python Package
 """
-__version__ = "3.0.0rc6"
+__version__ = "3.0.0rc8"

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/src/peakrdl_python/__peakrdl__.py

@@ -80,7 +80,8 @@ class Exporter(ExporterSubcommandPlugin):
         arg_group.add_argument('--legacy_block_access', action='store_true',
                                dest='legacy_block_access',
                                help='peakrdl python has two methods to hold blocks of data, the '
-                                    'legacy mode based on array.array or the new mode using lists')
+                                    'legacy mode based on array.array or the new mode using '
+                                    'lists. This option will be removed in version 4.0')
         arg_group.add_argument('--show_hidden', action='store_true',
                                dest='show_hidden',
                                help='show addrmap, regfile, memory, register and fields that '
@@ -100,7 +101,8 @@ class Exporter(ExporterSubcommandPlugin):
                                dest='legacy_enum_type',
                                help='peakrdl python has two ways to define field encoding as '
                                      'enums new method and an old method based on IntEnum. '
-                                     'Setting this to true will restore the old behaviour')
+                                     'Setting this to true will restore the old behaviour.'
+                                     ' This option will be removed in version 4.0')
         arg_group.add_argument('--skip_systemrdl_name_and_desc_properties', action='store_true',
                                dest='skip_systemrdl_name_and_desc_properties',
                                help='peakrdl python includes the system RDL name and desc '

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/src/peakrdl_python/exporter.py

@@ -47,7 +47,7 @@ from .systemrdl_node_utility_functions import get_reg_writable_fields, \
     get_field_default_value, get_enum_values, get_properties_to_include, \
     HideNodeCallback, hide_based_on_property, \
     full_slice_accessor, ShowUDPCallback, \
-    node_iterator_entry
+    node_iterator_entry, simulator_field_definition
 from .unique_component_iterator import UniqueComponents
 from .unique_component_iterator import PeakRDLPythonUniqueRegisterComponents
 from .unique_component_iterator import PeakRDLPythonUniqueMemoryComponents
@@ -676,16 +676,17 @@ class PythonExporter:
                 raise TypeError(f'node should be a register, got {type(node)}')
             reg_addr = node.absolute_address
             if reg_addr in reg_dict:
+                if not node.has_overlaps:
+                    raise RuntimeError('A non-overlaping node should not have a duplicate address')
                 existing_entry = reg_dict[reg_addr]
-                # if the entry is already list simply append to it
-                if isinstance(existing_entry, list):
-                    existing_entry.append(node)
-                elif isinstance(existing_entry, RegNode):
-                    reg_dict[reg_addr] = [existing_entry, node]
-                else:
-                    raise TypeError(f'exiting entry of unexpected type: {type(existing_entry)}')
+                if not isinstance(existing_entry, list):
+                    raise RuntimeError('A overlapping entry should have been made as list')
+                existing_entry.append(node)
             else:
-                reg_dict[reg_addr] = node
+                if node.has_overlaps:
+                    reg_dict[reg_addr] = [node,]
+                else:
+                    reg_dict[reg_addr] = node
 
 
         context = {
@@ -697,7 +698,8 @@ class PythonExporter:
             'asyncoutput': asyncoutput,
             'skip_lib_copy': skip_lib_copy,
             'legacy_block_access': legacy_block_access,
-            'list': list
+            'list': list,
+            'simulator_field_definition': simulator_field_definition,
         }
 
         module_name = top_block.inst_name
@@ -951,12 +953,12 @@ class PythonExporter:
                skip_test_case_generation: bool = False,
                delete_existing_package_content: bool = True,
                skip_library_copy: bool = False,
-               legacy_block_access: bool = True,
+               legacy_block_access: bool = False,
                show_hidden: bool = False,
                user_defined_properties_to_include: Optional[list[str]] = None,
                user_defined_properties_to_include_regex: Optional[str] = None,
                hidden_inst_name_regex: Optional[str] = None,
-               legacy_enum_type: bool = True,
+               legacy_enum_type: bool = False,
                skip_systemrdl_name_and_desc_properties: bool = False,
                skip_systemrdl_name_and_desc_in_docstring: bool = False,
                register_class_per_generated_file: int =
@@ -1011,6 +1013,7 @@ class PythonExporter:
             legacy_enum_type: version 1.2 introduced a new Enum type that allows system
                               rdl ``name`` and ``desc`` properties on field encoding
                               to be included. The legacy mode uses python IntEnum.
+                              .. version-deprecated:: 3.0
             skip_systemrdl_name_and_desc_properties (bool) : version 1.2 introduced new properties
                                                              that include the systemRDL name and
                                                              desc as properties of the built
@@ -1053,6 +1056,16 @@ class PythonExporter:
         Returns:
             modules that have been exported:
         """
+        if legacy_enum_type:
+            warnings.warn('legacy_enum_type is deprecated and '
+                          'will be removed from a future version please try the new mode',
+                          category=DeprecationWarning)
+
+        if legacy_block_access:
+            warnings.warn('legacy_block_access is deprecated and '
+                          'will be removed from a future version please try the new mode',
+                          category=DeprecationWarning)
+
 
         # If it is the root node, skip to top addrmap
         if isinstance(node, RootNode):

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/src/peakrdl_python/lib/base_field.py

@@ -385,28 +385,6 @@ class _FieldReadOnlyFramework(Field[FieldType], ABC):
     """
     __slots__ : list[str] = []
 
-    def decode_read_value(self, value: int) -> FieldType:
-        """
-        extracts the field value from a register value, by applying the bit
-        mask and shift needed
-
-        Args:
-            value: value to decode, normally read from a register
-
-        Returns:
-            field value
-
-        Warning:
-            This method will be removed from a future version, if you have a compelling use
-            case for it please add a comment to the #184 ticket
-
-        """
-        # end users should not need access to the `decode_read_value` as the decoding is done
-        # for them, it felt like an anomaly that this was public, see #184
-        warnings.warn('decode_read_value will be made private in a future version',
-                      DeprecationWarning, stacklevel=2)
-        return self._decode_read_value(value=value)
-
     def _decode_read_value(self, value: int) -> FieldType:
         """
         extracts the field value from a register value, by applying the bit
@@ -476,29 +454,6 @@ class _FieldWriteOnlyFramework(Field[FieldType], ABC):
             raise ValueError(f'value to be written to register must be less '
                              f'than or equal to {self.max_value:d}')
 
-
-    def encode_write_value(self, value: FieldType) -> int:
-        """
-        Check that a value is legal for the field and then encode it in preparation to be written
-        to the register
-
-        Args:
-            value: field value
-
-        Returns:
-            value which can be applied to the register to update the field
-
-        Warning:
-            This method will be removed from a future version, if you have a compelling use
-            case for it please add a comment to the #184 ticket
-
-        """
-        # end users should not need access to the `decode_read_value` as the decoding is done
-        # for them, it felt like an anomaly that this was public, see #184
-        warnings.warn('encode_write_value will be made private in a future version',
-                      DeprecationWarning, stacklevel=2)
-        return self._encode_write_value(value=value)
-
     def _encode_write_value(self, value: FieldType) -> int:
         """
         Check that a value is legal for the field and then encode it in preparation to be written

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/src/peakrdl_python/lib_test/__init__.py

@@ -18,8 +18,8 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 This package is intended to distributed as part of automatically generated code by the PeakRDL
 Python tool. It provides a set of base test classes to reduce the size of the auto generated code
 """
-from .base_reg_test_class import LibTestBase
-from .async_reg_base_test_class import AsyncLibTestBase
+from .test_class import LibTestBase
+from .async_test_class import AsyncLibTestBase
 
 from .utilities import reverse_bits
 

peakrdl_python-3.0.0rc8/src/peakrdl_python/lib_test/_async_base_test_class.py

@@ -0,0 +1,61 @@
+"""
+peakrdl-python is a tool to generate Python Register Access Layer (RAL) from SystemRDL
+Copyright (C) 2021 - 2025
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation, either version 3 of
+the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+This package is intended to distributed as part of automatically generated code by the PeakRDL
+Python tool. It provide the base class for the autogenerated tests
+"""
+# this module is very similar to the non-async version, a lot of code has been put into common
+# methods but it did not make sense to do everything as it would destroy readability
+# pylint:disable=duplicate-code
+
+import unittest
+from abc import ABC, abstractmethod
+
+from ._common_base_test_class import CommonTestBase
+
+class AsyncLibTestCommon(unittest.IsolatedAsyncioTestCase, CommonTestBase, ABC):
+    """
+    Base Test class for the autogenerated register test when in async mode
+    """
+
+    # The following may look odd by a second layer of indirection is required to effectively patch
+    # the read and write within tests
+
+    # pylint:disable=missing-function-docstring
+
+    async def outer_read_callback(self, addr: int, width: int, accesswidth: int) -> int:
+        return await self.read_callback(addr=addr,
+                                        width=width,
+                                        accesswidth=accesswidth)
+
+    @abstractmethod
+    async def read_callback(self, addr: int, width: int, accesswidth: int) -> int:
+        ...
+
+    async def outer_write_callback(self, addr: int,
+                                   width: int, accesswidth: int,
+                                   data: int) -> None:
+        return await self.write_callback(addr=addr,
+                                         width=width,
+                                         accesswidth=accesswidth,
+                                         data=data)
+
+    @abstractmethod
+    async def write_callback(self, addr: int, width: int, accesswidth: int, data: int) -> None:
+        ...
+
+    # pylint:enable=missing-function-docstring

peakrdl_python-3.0.0rc8/src/peakrdl_python/lib_test/_base_test_class.py

@@ -0,0 +1,53 @@
+"""
+peakrdl-python is a tool to generate Python Register Access Layer (RAL) from SystemRDL
+Copyright (C) 2021 - 2025
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation, either version 3 of
+the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+This package is intended to distributed as part of automatically generated code by the PeakRDL
+Python tool. It provide the base class for the autogenerated tests
+"""
+from abc import ABC, abstractmethod
+
+from ._common_base_test_class import CommonTestBase
+
+
+class LibTestCommon(CommonTestBase, ABC):
+    """
+    Base Test class for the autogenerated register test when in non-async mode
+    """
+
+    # The following may look odd by a second layer of indirection is required to effectively patch
+    # the read and write within tests
+
+    # pylint:disable=missing-function-docstring
+
+    def outer_read_callback(self, addr: int, width: int, accesswidth: int) -> int:
+        return self.read_callback(addr=addr, width=width, accesswidth=accesswidth)
+
+    @abstractmethod
+    def read_callback(self, addr: int, width: int, accesswidth: int) -> int:
+        ...
+
+    def outer_write_callback(self, addr: int, width: int, accesswidth: int,  data: int) -> None:
+        return self.write_callback(addr=addr, width=width, accesswidth=accesswidth, data=data)
+
+    @abstractmethod
+    def write_callback(self, addr: int, width: int, accesswidth: int,  data: int) -> None:
+        ...
+
+    # pylint:enable=missing-function-docstring

{peakrdl_python-3.0.0rc6 → peakrdl_python-3.0.0rc8}/src/peakrdl_python/lib_test/_common_base_test_class.py

@@ -41,20 +41,23 @@ from ..lib import MemoryAsyncReadWrite, MemoryAsyncReadWriteLegacy
 from ..lib.base_register import BaseReg
 from ..lib import Node
 from ..lib import Base
+from ..lib import SystemRDLEnum
 from .utilities import get_field_bitmask_int, get_field_inv_bitmask
 from ..sim_lib.simulator import BaseSimulator
 
+
 class NodeIterators:
     """
     The Node Iterator class is intended to an efficient way to define the iterators of particular
     type that are present on a node
     """
     __slots__ = ['__node_descriptions']
-    def __init__(self, *args:Union[str, tuple[str, list[int]]]):
+
+    def __init__(self, *args: Union[str, tuple[str, list[int]]]):
         self.__node_descriptions = args
 
     @staticmethod
-    def __rolled_item(item:Union[str, tuple[str, list[int]]]) -> str:
+    def __rolled_item(item: Union[str, tuple[str, list[int]]]) -> str:
         if isinstance(item, tuple):
             return item[0]
         return item
@@ -64,7 +67,7 @@ class NodeIterators:
         """
         name of all the rolled nodes in a set
         """
-        return { self.__rolled_item(item) for item in self.__node_descriptions }
+        return {self.__rolled_item(item) for item in self.__node_descriptions}
 
     @property
     def unrolled(self) -> set[str]:
@@ -74,7 +77,7 @@ class NodeIterators:
         return_list = []
         for item in self.__node_descriptions:
             if isinstance(item, tuple):
-                dim_set =  list(product(*[range(dim) for dim in item[1]]))
+                dim_set = list(product(*[range(dim) for dim in item[1]]))
                 for dim in dim_set:
                     # to match the systemrdl compiler dimension put into the inst name of
                     # the array, the name must be item[x][y]
@@ -84,6 +87,7 @@ class NodeIterators:
                 return_list.append(item)
         return set(return_list)
 
+
 class CommonTestBase(unittest.TestCase, ABC):
     """
     Base Test class for the autogenerated register test to be used for the async and
@@ -107,17 +111,17 @@ class CommonTestBase(unittest.TestCase, ABC):
     # pylint:disable-next=too-many-arguments
     def _single_field_property_test(self, *,
                                     fut: Union[FieldReadWrite,
-                                               FieldReadOnly,
-                                               FieldWriteOnly,
-                                               FieldEnumReadWrite,
-                                               FieldEnumReadOnly,
-                                               FieldEnumWriteOnly,
-                                               FieldAsyncReadOnly,
-                                               FieldAsyncWriteOnly,
-                                               FieldAsyncReadWrite,
-                                               FieldEnumAsyncReadOnly,
-                                               FieldEnumAsyncWriteOnly,
-                                               FieldEnumAsyncReadWrite],
+                                    FieldReadOnly,
+                                    FieldWriteOnly,
+                                    FieldEnumReadWrite,
+                                    FieldEnumReadOnly,
+                                    FieldEnumWriteOnly,
+                                    FieldAsyncReadOnly,
+                                    FieldAsyncWriteOnly,
+                                    FieldAsyncReadWrite,
+                                    FieldEnumAsyncReadOnly,
+                                    FieldEnumAsyncWriteOnly,
+                                    FieldEnumAsyncReadWrite],
                                     lsb: int,
                                     msb: int,
                                     low: int,
@@ -137,7 +141,7 @@ class CommonTestBase(unittest.TestCase, ABC):
         self.assertEqual(fut.inverse_bitmask, get_field_inv_bitmask(fut))
         width = (fut.high - fut.low) + 1
         self.assertEqual(fut.width, width)
-        self.assertEqual(fut.max_value, (2**width) - 1)
+        self.assertEqual(fut.max_value, (2 ** width) - 1)
         self.assertEqual(fut.is_volatile, is_volatile)
 
         if default is None:
@@ -284,9 +288,9 @@ class CommonTestBase(unittest.TestCase, ABC):
         self.__bad_attribute_test(dut=dut)
 
     def __single_node_rdl_name_and_desc_test(self,
-                                            dut: Base,
-                                            rdl_name: Optional[str],
-                                            rdl_desc: Optional[str]) -> None:
+                                             dut: Base,
+                                             rdl_name: Optional[str],
+                                             rdl_desc: Optional[str]) -> None:
         """
         Check the SystemRDL Name and Desc properties for a node
         """
@@ -302,8 +306,8 @@ class CommonTestBase(unittest.TestCase, ABC):
 
     def __test_node_inst_name(self,
                               dut: Base,
-                              parent_full_inst_name:Optional[str],
-                              inst_name:str) -> None:
+                              parent_full_inst_name: Optional[str],
+                              inst_name: str) -> None:
         """
         Test the `inst_name` and `full_inst_name` attributes of a node
         """
@@ -337,11 +341,11 @@ class CommonTestBase(unittest.TestCase, ABC):
 
     def _test_field_iterators(self, *,
                               rut: Union[RegReadOnly,
-                                         RegReadWrite,
-                                         RegWriteOnly,
-                                         RegAsyncReadOnly,
-                                         RegAsyncReadWrite,
-                                         RegAsyncWriteOnly],
+                              RegReadWrite,
+                              RegWriteOnly,
+                              RegAsyncReadOnly,
+                              RegAsyncReadWrite,
+                              RegAsyncWriteOnly],
                               has_sw_readable: bool,
                               has_sw_writable: bool,
                               readable_fields: set[str],
@@ -354,7 +358,7 @@ class CommonTestBase(unittest.TestCase, ABC):
                                     )):
                 raise TypeError(f'Register was expected to readable, got {type(rut)}')
 
-            child_readable_field_names = { field.inst_name for field in rut.readable_fields}
+            child_readable_field_names = {field.inst_name for field in rut.readable_fields}
 
             self.assertEqual(readable_fields, child_readable_field_names)
         else:
@@ -382,16 +386,16 @@ class CommonTestBase(unittest.TestCase, ABC):
         self.assertEqual(readable_fields | writeable_fields, child_field_names)
 
         # Check the child name map
-        self.__test_name_map(dut=rut, child_names= readable_fields | writeable_fields)
+        self.__test_name_map(dut=rut, child_names=readable_fields | writeable_fields)
 
     def _test_register_iterators(self,
                                  dut: Union[AddressMap, AsyncAddressMap, RegFile, AsyncRegFile,
-                                            MemoryReadOnly, MemoryReadOnlyLegacy,
-                                            MemoryWriteOnly, MemoryWriteOnlyLegacy,
-                                            MemoryReadWrite, MemoryReadWriteLegacy,
-                                            MemoryAsyncReadOnly, MemoryAsyncReadOnlyLegacy,
-                                            MemoryAsyncWriteOnly, MemoryAsyncWriteOnlyLegacy,
-                                            MemoryAsyncReadWrite, MemoryAsyncReadWriteLegacy],
+                                 MemoryReadOnly, MemoryReadOnlyLegacy,
+                                 MemoryWriteOnly, MemoryWriteOnlyLegacy,
+                                 MemoryReadWrite, MemoryReadWriteLegacy,
+                                 MemoryAsyncReadOnly, MemoryAsyncReadOnlyLegacy,
+                                 MemoryAsyncWriteOnly, MemoryAsyncWriteOnlyLegacy,
+                                 MemoryAsyncReadWrite, MemoryAsyncReadWriteLegacy],
                                  readable_registers: NodeIterators,
                                  writeable_registers: NodeIterators) -> None:
 
@@ -400,8 +404,8 @@ class CommonTestBase(unittest.TestCase, ABC):
                             MemoryReadWrite, MemoryReadWriteLegacy,
                             MemoryAsyncReadOnly, MemoryAsyncReadOnlyLegacy,
                             MemoryAsyncReadWrite, MemoryAsyncReadWriteLegacy)):
-            child_readable_reg_names = { reg.inst_name for reg in
-                                         dut.get_readable_registers(unroll=True)}
+            child_readable_reg_names = {reg.inst_name for reg in
+                                        dut.get_readable_registers(unroll=True)}
             self.assertEqual(readable_registers.unrolled, child_readable_reg_names)
             child_readable_reg_names = {reg.inst_name for reg in
                                         dut.get_readable_registers(unroll=False)}
@@ -443,7 +447,6 @@ class CommonTestBase(unittest.TestCase, ABC):
                                  child_names=readable_registers.rolled |
                                              writeable_registers.rolled)
 
-
     def _test_memory_iterators(self,
                                dut: Union[AddressMap, AsyncAddressMap],
                                memories: NodeIterators) -> None:
@@ -494,3 +497,56 @@ class CommonTestBase(unittest.TestCase, ABC):
         self.__test_name_map(dut=dut, child_names=readable_registers.rolled |
                                                   writeable_registers.rolled |
                                                   sections.rolled)
+
+    def _full_to_reduced_enum_conversion(
+            self,
+            full_enum_def: dict[str, tuple[int, Optional[str], Optional[str]]]) -> dict[str, int]:
+        return {key:value[0] for key,value in full_enum_def.items() }
+
+    def _test_enum_def_rdl_name_desc_(
+            self,
+            fut: Union[FieldEnumReadOnly, FieldEnumReadOnly, FieldEnumWriteOnly,
+                       FieldEnumAsyncReadOnly, FieldEnumAsyncReadOnly, FieldEnumAsyncWriteOnly],
+            full_enum_def: dict[str, tuple[int, Optional[str], Optional[str]]]) -> None:
+        """
+        Check that the enumeration in the field matches the enumeration specifed in the
+        systemRDL
+
+        Args:
+            fut: field node
+            full_enum_def: definition of the enumeration a dictionary, with the of the
+                           entry as a key and the value a tuple that has:
+                           1. int value encoding the enumeration
+                           2. system RDL name (or None)
+                           3. system RDL name (or None)
+
+        Returns: None
+
+        """
+
+        # pylint does not realise this is a class being returned rather than an object, so
+        # is unhappy with the name
+        # pylint:disable-next=invalid-name
+        EnumCls = fut.enum_cls
+        for name, value in full_enum_def.items():
+            enum_inst = EnumCls[name]
+            self.assertEqual(enum_inst.value, value[0])
+
+            if issubclass(EnumCls, SystemRDLEnum):
+                if value[1] is None:
+                    self.assertIsNone(enum_inst.rdl_name)
+                else:
+                    self.assertEqual(enum_inst.rdl_name, value[1])
+
+                if value[2] is None:
+                    self.assertIsNone(enum_inst.rdl_desc)
+                else:
+                    self.assertEqual(enum_inst.rdl_desc, value[2])
+
+            else:
+                # if using a legacy enumeration, then the systemRDL name and desc must be None
+                # as the legacy enum did not support these
+                self.assertIsNone(value[1])
+                self.assertIsNone(value[2])
+                self.assertFalse(hasattr(enum_inst, 'rdl_name'))
+                self.assertFalse(hasattr(enum_inst, 'rdl_desc'))