Merge pull request #239 from krcb197/238-optimised-test_enum_field_read_and_write

Optimise the `test_enum_field_read_and_write`

Author: krcb197

generate_and_test.py

@@ -36,7 +36,7 @@
 
 #from coverage import Coverage
 
-#from peakrdl_ipxact import IPXACTImporter
+from peakrdl_ipxact import IPXACTImporter
 
 sys.path.append('src')
 from peakrdl_python import PythonExporter
@@ -46,6 +46,8 @@
 CommandLineParser = argparse.ArgumentParser(description='Test the framework')
 CommandLineParser.add_argument('--RDL_source_file', dest='root_RDL_file',
                                type=pathlib.Path, required=True)
+CommandLineParser.add_argument('--RDL_additional_file', dest='additional_file_RDL_file',
+                               type=pathlib.Path)
 CommandLineParser.add_argument('--root_node', dest='root_node',
                                type=str, required=True)
 CommandLineParser.add_argument('--output', dest='output_path',
@@ -195,6 +197,8 @@ def build_logging_cong(logfilepath:str):
         else:
             raise(RuntimeError('not a list'))
 
+    if CommandLineArgs.additional_file_RDL_file is not None:
+        rdlc.compile_file(CommandLineArgs.additional_file_RDL_file)
     rdlc.compile_file(CommandLineArgs.root_RDL_file)
     spec = rdlc.elaborate(top_def_name=CommandLineArgs.root_node).top
 

src/peakrdl_python/lib_test/async_reg_base_test_class.py

@@ -25,16 +25,18 @@
 import unittest
 from abc import ABC
 from typing import Union
-import random
 from unittest.mock import patch
 from itertools import product
 
 from ..lib import FieldAsyncReadOnly, FieldAsyncWriteOnly, FieldAsyncReadWrite
+from ..lib import FieldEnumAsyncReadOnly, FieldEnumAsyncWriteOnly, FieldEnumAsyncReadWrite
 from ..sim_lib.dummy_callbacks import async_dummy_read
 from ..sim_lib.dummy_callbacks import async_dummy_write
 
 
 from .utilities import reverse_bits, expected_reg_write_data
+from .utilities import reg_value_for_field_read_with_random_base
+from .utilities import random_field_value, random_field_parent_reg_value
 
 class AsyncLibTestBase(unittest.IsolatedAsyncioTestCase, ABC):
     """
@@ -119,14 +121,14 @@ async def __single_field_read_test(
 
             # read back - random value
             read_callback_mock.reset_mock()
-            random_value = random.randrange(0, fut.parent_register.max_value + 1)
+            random_value = random_field_parent_reg_value(fut)
             read_callback_mock.return_value = random_value
-            random_field_value = (random_value & fut.bitmask) >> fut.low
+            field_value = (random_value & fut.bitmask) >> fut.low
             if fut.msb == fut.high:
-                self.assertEqual(await fut.read(), random_field_value)
+                self.assertEqual(await fut.read(), field_value)
             else:
                 self.assertEqual(await fut.read(),
-                                 reverse_bits(value=random_field_value, number_bits=fut.width))
+                                 reverse_bits(value=field_value, number_bits=fut.width))
             read_callback_mock.assert_called_once_with(
                 addr=fut.parent_register.address,
                 width=fut.parent_register.width,
@@ -146,13 +148,9 @@ async def __single_field_write_test(
             # pylint:disable-next=protected-access
             readable_reg = fut.parent_register._is_readable
 
-
-
-            random_reg_value = random.randrange(0, fut.parent_register.max_value + 1)
-            random_field_value = random.randrange(0, fut.max_value + 1)
             for reg_base_value, field_value in product(
-                    [0, fut.parent_register.max_value, random_reg_value],
-                    [0, fut.max_value, random_field_value]):
+                    [0, fut.parent_register.max_value, random_field_parent_reg_value(fut)],
+                    [0, fut.max_value, random_field_value(fut)]):
                 read_callback_mock.reset_mock()
                 write_callback_mock.reset_mock()
                 read_callback_mock.return_value = reg_base_value
@@ -183,3 +181,125 @@ async def __single_field_write_test(
 
                 with self.assertRaises(ValueError):
                     await fut.write(-1)
+
+    async def __single_enum_field_read_test(self,
+                                      fut: Union[FieldEnumAsyncReadOnly, FieldEnumAsyncReadOnly],
+                                      enum_definition: dict[str, int],
+                                      ) -> 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
+
+        with patch.object(self, 'write_callback') as write_callback_mock, \
+                patch.object(self, 'read_callback', return_value=0) as read_callback_mock:
+
+            # read back - each legal enum value
+            for enum_name, enum_value in enum_definition.items():
+                read_callback_mock.reset_mock()
+                reg_value = reg_value_for_field_read_with_random_base(fut=fut,
+                                                                      field_value= enum_value)
+                read_callback_mock.return_value = reg_value
+                self.assertEqual(await fut.read(), EnumCls[enum_name])
+                read_callback_mock.assert_called_once_with(
+                    addr=fut.parent_register.address,
+                    width=fut.parent_register.width,
+                    accesswidth=fut.parent_register.accesswidth)
+
+            # check register values that don't map to a legal enum value create an exception
+            # this check is only relevant if there are potential field values that do not map to
+            # the enum
+            if len(enum_definition) < (2**fut.width):
+                # there are two versions of this:
+                # 1) for small fields (up to 8 bit wide) every value is tested
+                # 2) for large fields (typically occurring with a sparse enum 100 values are
+                #    checked
+                legal_enum_values_set = set(enum_definition.values())
+                if fut.width <= 8:
+                    bad_field_value_iter = set(range(fut.max_value+1))
+                else:
+                    bad_field_value_iter = {random_field_value(fut) for _ in range(100)}
+
+                for bad_field_value in bad_field_value_iter - legal_enum_values_set:
+                    read_callback_mock.reset_mock()
+                    reg_value = reg_value_for_field_read_with_random_base(
+                        fut=fut,
+                        field_value=bad_field_value)
+                    read_callback_mock.return_value = reg_value
+                    with self.assertRaises(ValueError):
+                        _ = await fut.read()
+                    read_callback_mock.assert_called_once_with(
+                        addr=fut.parent_register.address,
+                        width=fut.parent_register.width,
+                        accesswidth=fut.parent_register.accesswidth)
+
+            # at the end of the read tests the write should not have been called
+            write_callback_mock.assert_not_called()
+
+    async def __single_enum_field_write_test(self,
+                                      fut: Union[FieldEnumAsyncWriteOnly, FieldEnumAsyncReadWrite],
+                                      enum_definition: dict[str, int]) -> 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
+
+        # pylint:disable-next=protected-access
+        readable_reg = fut.parent_register._is_readable
+
+        with patch.object(self, 'write_callback') as write_callback_mock, \
+                patch.object(self, 'read_callback', return_value=0) as read_callback_mock:
+
+            for enum_name, enum_value in enum_definition.items():
+                random_reg_value = random_field_parent_reg_value(fut)
+                read_callback_mock.return_value = random_reg_value
+                await fut.write(EnumCls[enum_name])
+
+                # the read is skipped if the register is not readable or has the same width
+                # as the field
+                if (fut.width < fut.parent_register.width) and readable_reg:
+                    read_callback_mock.assert_called_once_with(
+                        addr=fut.parent_register.address,
+                        width=fut.parent_register.width,
+                        accesswidth=fut.parent_register.accesswidth)
+                else:
+                    read_callback_mock.assert_not_called()
+
+                write_callback_mock.assert_called_once_with(
+                    addr=fut.parent_register.address,
+                    width=fut.parent_register.width,
+                    accesswidth=fut.parent_register.accesswidth,
+                    data=expected_reg_write_data(fut=fut,
+                                                 reg_base_value=random_reg_value,
+                                                 readable_reg=readable_reg,
+                                                 field_value=enum_value))
+
+                read_callback_mock.reset_mock()
+                write_callback_mock.reset_mock()
+
+    async def _single_enum_field_read_and_write_test(
+            self,
+            fut: Union[FieldEnumAsyncReadOnly, FieldEnumAsyncReadOnly, FieldEnumAsyncWriteOnly],
+            enum_definition: dict[str, int],
+            is_sw_readable: bool,
+            is_sw_writable: bool) -> None:
+        """
+        Check the ability to read and write to integer (non-encoded) field
+        """
+
+        # the lsb, msb, high, low, bitmask, inv_bitmask and max_value are all checked as part of
+        # `test_field_properties` so do not need to checked here. Similarly, the properties of
+        # parent register are checked as part of `test_register_properties`
+
+        if is_sw_readable:
+            if not isinstance(fut, (FieldEnumAsyncReadOnly, FieldEnumAsyncReadWrite)):
+                raise TypeError('Test can not proceed as the fut is not a readable field')
+            await self.__single_enum_field_read_test(fut=fut,
+                                               enum_definition=enum_definition)
+
+        if is_sw_writable:
+            if not isinstance(fut, (FieldEnumAsyncWriteOnly, FieldEnumAsyncReadWrite)):
+                raise TypeError('Test can not proceed as the fut is not a writable field')
+            await self.__single_enum_field_write_test(fut=fut,
+                                                enum_definition=enum_definition)