Merge pull request #242 from krcb197/240-optimised-test_field_properties

240 optimised `test_field_properties`

Author: krcb197

src/peakrdl_python/lib_test/_common_base_test_class.py

@@ -0,0 +1,88 @@
+"""
+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 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 General Public License for more details.
+
+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 common to both the async and non-async versions
+"""
+import unittest
+from abc import ABC
+from typing import Union, Optional
+
+from ..lib import FieldReadWrite, FieldReadOnly, FieldWriteOnly
+from ..lib import FieldEnumReadWrite, FieldEnumReadOnly, FieldEnumWriteOnly
+from ..lib import FieldAsyncReadOnly, FieldAsyncWriteOnly, FieldAsyncReadWrite
+from ..lib import FieldEnumAsyncReadOnly, FieldEnumAsyncWriteOnly, FieldEnumAsyncReadWrite
+
+class CommonTestBase(unittest.TestCase, ABC):
+    """
+    Base Test class for the autogenerated register test to be used for for the async and
+    non-async cases
+    """
+
+    # 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],
+                                    lsb: int,
+                                    msb: int,
+                                    low: int,
+                                    high: int,
+                                    bitmask: int,
+                                    inverse_bitmask: int,
+                                    max_value: int,
+                                    is_volatile: bool,
+                                    default: Optional[int]) -> None:
+        self.assertEqual(fut.lsb, lsb)
+        self.assertEqual(fut.msb, msb)
+        self.assertEqual(fut.low, low)
+        self.assertEqual(fut.high, high)
+        self.assertEqual(fut.bitmask, bitmask)
+        self.assertEqual(fut.inverse_bitmask, inverse_bitmask)
+        self.assertEqual(fut.max_value, max_value)
+        self.assertEqual(fut.is_volatile, is_volatile)
+
+        if default is None:
+            self.assertIsNone(fut.default)
+        else:
+            if isinstance(fut, (FieldEnumReadWrite,
+                                FieldEnumReadOnly,
+                                FieldEnumWriteOnly,
+                                FieldEnumAsyncReadOnly,
+                                FieldEnumAsyncWriteOnly,
+                                FieldEnumAsyncReadWrite)):
+                # 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
+                if default in [item.value for item in fut.enum_cls]:
+                    self.assertEqual(fut.default, EnumCls(default))
+                else:
+                    # this is a special case if the default value for the field does not map
+                    # to a legal value of the encoding
+                    self.assertIsNone(fut.default)
+            else:
+                self.assertEqual(fut.default, default)

src/peakrdl_python/lib_test/async_reg_base_test_class.py

@@ -38,7 +38,9 @@
 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):
+from ._common_base_test_class import CommonTestBase
+
+class AsyncLibTestBase(unittest.IsolatedAsyncioTestCase, CommonTestBase, ABC):
     """
     Base Test class for the autogenerated register test when in async mode
     """

src/peakrdl_python/lib_test/base_reg_test_class.py

@@ -18,7 +18,6 @@
 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
 """
-import unittest
 from abc import ABC
 from typing import Union
 from unittest.mock import patch
@@ -33,7 +32,9 @@
 from .utilities import reg_value_for_field_read_with_random_base
 from .utilities import random_field_value, random_field_parent_reg_value
 
-class LibTestBase(unittest.TestCase, ABC):
+from ._common_base_test_class import CommonTestBase
+
+class LibTestBase(CommonTestBase, ABC):
     """
     Base Test class for the autogenerated register test when in async mode
     """

src/peakrdl_python/systemrdl_node_utility_functions.py

@@ -420,7 +420,7 @@ def get_field_default_value(node: FieldNode) -> Optional[int]:
         return value
 
     if isinstance(value, (FieldNode, SignalNode)):
-        # if the node resets to an external external signal or value of another field, there is no
+        # if the node resets to an external signal or value of another field, there is no
         # knowledge the code can have of this state and it gets treated as None
         return None
 

src/peakrdl_python/templates/addrmap_tb.py.jinja

@@ -179,42 +179,6 @@ class {{fq_block_name}}_single_access({{top_node.inst_name}}_TestCase): # type:
             {% if 'accesswidth' in node.list_properties() -%}self.assertEqual(mut.accesswidth, {{node.get_property('accesswidth')}}){%- else -%}self.assertEqual(mut.accesswidth, mut.accesswidth){%- endif %}
         {% endfor %}
 
-    def test_field_properties(self)  -> None:
-        """
-        walk the address map and check:
-        - that the lsb and msb of every field is correct
-        - that where default values are provided they are applied correctly
-        """
-        fut:Field
-        {% for node in owned_elements.fields -%}
-        with self.subTest(msg='field: {{'.'.join(node.get_path_segments())}}'):
-            # test properties of field: {{'.'.join(node.get_path_segments())}}
-            fut = self.dut.{{'.'.join(get_python_path_segments(node))}} # type: ignore[union-attr]
-            if not isinstance(fut, Field):
-                raise TypeError('This test relies on node being of type Field')
-            self.assertEqual(fut.lsb,{{node.lsb}})
-            self.assertEqual(fut.msb,{{node.msb}})
-            self.assertEqual(fut.low,{{node.low}})
-            self.assertEqual(fut.high,{{node.high}})
-            self.assertEqual(fut.bitmask,{{get_field_bitmask_hex_string(node)}})
-            self.assertEqual(fut.inverse_bitmask,{{get_field_inv_bitmask_hex_string(node)}})
-            self.assertEqual(fut.max_value,{{get_field_max_value_hex_string(node)}})
-                {% if 'encode' in node.list_properties() %}
-                {# only attempt to test enum fields if the reset value is legal for the field #}
-                    {% if get_field_default_value(node) in get_enum_values(node.get_property('encode')) %}
-            if fut.default is None:
-                # This is needed to ensure type checking with mypy is happy
-                raise TypeError('The default should be set')
-            self.assertEqual(fut.default.value,{{get_field_default_value(node)}})
-                    {% else %}
-            self.assertIsNone(fut.default)
-                    {% endif %}
-                {% else %}
-            self.assertEqual(fut.default,{{get_field_default_value(node)}})
-                {% endif %}
-            self.assertEqual(fut.is_volatile,{{node.is_hw_writable}})
-        {% endfor %}
-
     def test_field_encoding_properties(self)  -> None:
         """
         Check that enumeration has the name and desc meta data from the systemRDL
@@ -382,12 +346,13 @@ class {{fq_block_name}}_single_access({{top_node.inst_name}}_TestCase): # type:
                 read_callback_mock.assert_not_called()
         {% endfor %}
 
-    {% if asyncoutput %}async {% endif %}def test_field_read_and_write(self) -> None:
+    {% if asyncoutput %}async {% endif %}def test_field(self) -> None:
         """
-        Check the ability to read and write to fields integer and enum
+        Check the properties and function (read and write) on the fields both integer and enum
         """
         {% for node in owned_elements.fields %}
         with self.subTest(msg='field: {{'.'.join(node.get_path_segments())}}'):
+            self._single_field_property_test(fut=self.dut.{{'.'.join(get_python_path_segments(node))}}, lsb={{node.lsb}}, msb={{node.msb}}, low={{node.low}}, high={{node.high}}, bitmask={{get_field_bitmask_hex_string(node)}}, inverse_bitmask={{get_field_inv_bitmask_hex_string(node)}}, max_value={{get_field_max_value_hex_string(node)}}, is_volatile={{node.is_hw_writable}}, default={{get_field_default_value(node)}})
             {%- if 'encode' not in node.list_properties() %}
             {% if asyncoutput %}await {%endif %}self._single_int_field_read_and_write_test(fut=self.dut.{{'.'.join(get_python_path_segments(node))}}, is_sw_readable={{node.is_sw_readable}}, is_sw_writable={{node.is_sw_writable}})
             {%- else %}

tests/unit_tests/test_export.py

@@ -25,7 +25,7 @@
 import tempfile
 import sys
 import re
-from itertools import chain, permutations, product
+from itertools import chain, combinations, product
 from pathlib import Path
 from array import array as Array
 import inspect
@@ -272,7 +272,7 @@ def check_udp_present(dut, udp_to_include:list[str]) -> None:
 
 
         for udp_to_include in chain.from_iterable(
-                [permutations(full_property_list, r) for r in range(len(full_property_list))]):
+                [combinations(full_property_list, r) for r in range(4)]):
             # check the list method
             with self.subTest(udp_to_include=udp_to_include), \
                     self.build_wrappers_and_import(udp_list=list(udp_to_include)) as dut: