Add regression test

Author: Risto97

src/peakrdl_halcpp/templates/test.cpp.j2

@@ -1,19 +1,33 @@
 #include "mock_io.h"
 #include "{{ top.orig_type_name }}_hal.h"
-#include "test_utils.h"
+#include "field_test_utils.h"
+#include "reg_test_utils.h"
 
 inline constexpr {{ top.orig_type_name|upper }}_HAL<0> {{ top.orig_type_name }}{};
 
-int main (int argc, char *argv[]) {
+int main () {
+
+{% for reg in regs %}
+    test_generic_reg({{ reg|resolve_path_array_refs }}, {{ reg.absolute_address }}, "{{ reg.get_path() }}");
+    {% if reg.has_sw_readable and reg.has_sw_writable %}
+    test_rw_reg({{ reg|resolve_path_array_refs }}, "{{ reg.get_path() }}");
+    {% elif reg.has_sw_readable and not reg.has_sw_writable %}
+    test_ro_reg({{ reg|resolve_path_array_refs }});
+    {% elif not reg.has_sw_readable and reg.has_sw_writable %}
+    test_wo_reg({{ reg|resolve_path_array_refs }});
+    {% endif %}
+
+{% endfor %}
 
 {% for field in fields %}
-    test_generic_field({{ field.get_path() }}, {{ field.width }}, {{ field.parent.absolute_address }}, {{ field.low }}, {{ field.high }}, "{{ field.get_path() }}");
+    {% set field_ref = field|resolve_path_array_refs %}
+    test_generic_field({{ field_ref }}, {{ field.width }}, {{ field.parent.absolute_address }}, {{ field.low }}, {{ field.high }}, "{{ field.get_path() }}");
     {% if field.is_sw_readable and field.is_sw_writable %}
-    test_rw_field<decltype({{ field.get_path() }}), {{ field.width }}>({{ field.get_path() }}, "{{ field.get_path() }}");
+    test_rw_field<decltype({{ field_ref }}), {{ field.width }}>({{ field_ref }}, "{{ field.get_path() }}");
     {% elif field.is_sw_readable and not field.is_sw_writable %}
-    test_ro_field<decltype({{ field.get_path() }}), {{ field.width }}>({{ field.get_path() }}, "{{ field.get_path() }}");
+    test_ro_field<decltype({{ field_ref }}), {{ field.width }}>({{ field_ref }});
     {% elif not field.is_sw_readable and field.is_sw_writable %}
-    test_wo_field<decltype({{ field.get_path() }}), {{ field.width }}>({{ field.get_path() }}, "{{ field.get_path() }}");
+    test_wo_field<decltype({{ field_ref }}), {{ field.width }}>({{ field_ref }});
     {% endif %}
 
 {% endfor %}

src/peakrdl_halcpp/templates/test_CMakeLists.txt.j2

@@ -20,6 +20,11 @@ function(hal_test TEST_NAME)
         test_utils
       )
 
+    target_compile_options(${TEST_NAME} PUBLIC
+        -fno-delete-null-pointer-checks
+        -Wall -Wextra -Wpedantic -Werror
+    )
+
     add_test(
       NAME ${TEST_NAME}
       COMMAND $<TARGET_FILE:${TEST_NAME}>

src/peakrdl_halcpp/test_generator.py

@@ -1,21 +1,26 @@
 from pathlib import Path
+import re
 import shutil
 import jinja2 as jj
 import os
 from typing import Any, Dict, Optional
-from systemrdl.node import AddrmapNode, FieldNode
+from systemrdl.node import AddrmapNode, FieldNode, Node, RegNode
 from systemrdl.walker import RDLListener, RDLWalker, WalkerAction
 
 
 class FieldListener(RDLListener):
 
     def __init__(self) -> None:
         self.fields: list[FieldNode] = []
+        self.regs: list[RegNode] = []
         self.curr_addrmap: AddrmapNode|None = None
 
     def enter_Field(self, node: FieldNode) -> Optional[WalkerAction]:
         self.fields.append(node)
 
+    def enter_Reg(self, node: RegNode) -> Optional[WalkerAction]:
+        self.regs.append(node)
+
     def enter_Addrmap(self, node: AddrmapNode) -> Optional[WalkerAction]:
         if self.curr_addrmap is None:
             self.curr_addrmap = node
@@ -30,6 +35,27 @@ def __init__(self) -> None:
     def enter_Addrmap(self, node: AddrmapNode) -> Optional[WalkerAction]:
         self.addrmaps.append(node)
 
+def transform_systemrdl_array_indices_to_halcpp(s):
+    # Match identifier followed by group of indexes reg0[0][2][4]
+    pattern = re.compile(r'([a-zA-Z_]\w*)((?:\[\d+\])+)' )
+
+    def repl(match):
+        ident = match.group(1)
+        brackets = match.group(2)
+        # extract numbers from [n]
+        nums = re.findall(r'\[(\d+)\]', brackets)
+        # replace it with .at<0, 2, 4>()
+        return f"{ident}.at<{','.join(nums)}>()"
+
+    return re.sub(pattern, repl, s)
+
+def resolve_path_array_refs(node: Node) -> str:
+    path = node.get_path()
+    # path = path.replace("[", ".template at<")
+    # path = path.replace("]", ">()")
+    path = transform_systemrdl_array_indices_to_halcpp(path)
+
+    return path
 
 class TestGenerator:
 
@@ -52,6 +78,7 @@ def export(self,
             context: dict[str, Any] = {
                     "top": node,
                     "fields": field_listener.fields,
+                    "regs": field_listener.regs,
                     }
             test_content: str = self.process_template(context, "test.cpp.j2")
 
@@ -103,6 +130,7 @@ def process_template(self,
         # Add the base zip function to the env
         env.filters.update({
             'zip': zip,
+            "resolve_path_array_refs": resolve_path_array_refs
         })
         # Render the C++ header text using the jinja2 template and the
         # specific context

src/peakrdl_halcpp/test_generator/test_utils/field_test_utils.h

@@ -0,0 +1,210 @@
+#ifndef __FIELD_TEST_UTILS_H_
+#define __FIELD_TEST_UTILS_H_
+
+#include <cstdint>
+#include <iostream>
+#include <cassert>
+#include "test_utils.h"
+
+/****************************/
+/***** Field Width test *****/
+/****************************/
+
+void assert_field_width(uint32_t expected_width,
+                        uint32_t actual_width,
+                        const char *field_path){
+    if(expected_width != actual_width){
+        std::cerr << "Field width test error for " << field_path;
+        std::cerr << "\n\tExpected width: " << std::dec << expected_width;
+        std::cerr << "\n\tActual width:   " << std::dec << actual_width << std::endl;
+        assert(expected_width == actual_width);
+    }
+}
+
+template<typename FIELD_T>
+void test_field_width(FIELD_T &field, uint32_t width, const char* field_path){
+    assert_field_width(width, field.get_width(), field_path);
+}
+
+/**********************************/
+/***** Field Base address test ****/
+/**********************************/
+
+void assert_field_base_address(uint32_t expected_base_address,
+                               uint32_t actual_base_address,
+                               const char *field_path){
+    if(expected_base_address != actual_base_address){
+        std::cerr << "Field base address test error for " << field_path;
+        std::cerr << "\n\tExpected base address: 0x" << std::hex << expected_base_address;
+        std::cerr << "\n\tActual base address:   0x" << std::hex << actual_base_address << std::endl;
+        assert(expected_base_address == actual_base_address);
+    }
+}
+
+template<typename FIELD_T>
+void test_field_base_address(FIELD_T &field, uint32_t base_address, const char* field_path){
+    assert_field_width(base_address, field.get_abs_addr(), field_path);
+}
+
+/**********************************/
+/*** Field start/end bit test *****/
+/**********************************/
+
+void assert_field_start_end_bit(uint32_t expected_start_bit,
+                               uint32_t actual_start_bit,
+                               uint32_t expected_end_bit,
+                               uint32_t actual_end_bit,
+                               const char *field_path){
+    if((expected_start_bit != actual_start_bit) or
+       (expected_end_bit   != actual_end_bit)){
+        std::cerr << "Field start/end test error for " << field_path;
+        std::cerr << "\n\tExpected start bit index: " << std::dec << expected_start_bit;
+        std::cerr << "\n\tActual start bit index:   " << std::dec << actual_start_bit;
+        std::cerr << "\n\tExpected end bit index: " << std::dec << expected_end_bit;
+        std::cerr << "\n\tActual end bit index:   " << std::dec << actual_end_bit << std::endl;
+        assert(expected_start_bit == actual_start_bit);
+        assert(expected_end_bit == actual_end_bit);
+    }
+}
+
+template<typename FIELD_T>
+void test_field_start_end_bit(FIELD_T &field, uint32_t start_bit, uint32_t end_bit, const char* field_path){
+    uint32_t read_start_bit = field.get_start_bit();
+    uint32_t read_end_bit = field.get_end_bit();
+    assert_field_start_end_bit(start_bit, read_start_bit, end_bit, read_end_bit, field_path);
+}
+
+/****************************/
+/****** RW Field test *******/
+/****************************/
+
+void assert_rw(uint32_t exp, uint32_t rec, const char* field_path){
+    if(exp != rec){
+        std::cerr << "Field RW test error for " << field_path;
+        std::cerr << "\n\tWrote: 0x" << std::hex << exp;
+        std::cerr << "\n\tRead:  0x" << std::hex << rec << "\n";
+        assert(exp == rec);
+    }
+}
+
+template<typename FIELD_T>
+void test_rw_field(uint32_t val, uint32_t exp, FIELD_T &field, const char* field_path){
+    field = val;
+
+    uint32_t result = field;
+    assert_rw(exp, result, field_path);
+}
+
+template<typename FIELD_T>
+void test_rw_field_marching_ones(FIELD_T &field, const char* field_path){
+    uint32_t width = field.get_width();
+    test_rw_field(0, 0, field, field_path);
+    for (uint32_t i = 0; i < width; i++) {
+        uint32_t write_val = 1 << i;
+        test_rw_field(write_val, write_val, field, field_path);
+    }
+}
+
+template<typename FIELD_T>
+void test_rw_field_overflow(FIELD_T &field, const char* field_path){
+    uint32_t width = field.get_width();
+    test_rw_field((1 << width), 0, field, field_path);
+}
+
+void assert_rw_at(uint32_t bit_idx, uint32_t exp_bit_val, uint32_t exp_field_val, uint32_t actual_field_val, const char* field_path) {
+    uint32_t mask = 1u << bit_idx;
+    uint32_t rec_bit = (actual_field_val & mask) ? 1u : 0u;
+
+    if ((exp_bit_val != rec_bit) or 
+        (exp_field_val != actual_field_val)) {
+        std::cerr << "Field RW at() accessor test error for " << field_path;
+        std::cerr << "\n\tBit index: " << std::dec << bit_idx;
+        std::cerr << "\n\tExpected:  " << exp_bit_val;
+        std::cerr << "\n\tBut read:  " << rec_bit;
+        std::cerr << "\n\tExpected field value:  0x" << std::hex << exp_field_val;
+        std::cerr << "\n\tActual field value:    0x" << std::hex << actual_field_val << "\n";
+        assert(exp_bit_val == rec_bit);
+        assert(exp_field_val == actual_field_val);
+    }
+}
+
+template<typename FIELD_T, uint32_t WIDTH>
+void test_rw_field_at_accessor(FIELD_T &field, const char* field_path){
+    test_rw_field(0, 0, field, field_path);
+    uint32_t exp_val = 0;
+    for_sequence<WIDTH>([&field, &exp_val, &field_path](auto i) {
+        field.template at<i>() = 1;
+        exp_val = exp_val | (1 << i);
+        assert_rw_at(i, 1, exp_val, field.get(), field_path);
+    });
+
+    // Set the last bit of the field to 0, (currently all bits are 1)
+    field.template at<-1>() = 0;
+    exp_val = (1 << (WIDTH-1)) - 1;
+    assert_rw_at(WIDTH-1, 0, exp_val, field.get(), field_path);
+}
+
+template<typename FIELD_T, uint32_t WIDTH>
+void test_rw_field(FIELD_T &field,
+                   const char* field_path){
+    test_rw_field_marching_ones(field, field_path);
+    test_rw_field_overflow(field, field_path);
+    test_rw_field_at_accessor<FIELD_T, WIDTH>(field, field_path);
+}
+
+
+/****************************/
+/****** RO Field test *******/
+/****************************/
+
+template<typename FIELD_T, uint32_t WIDTH>
+void test_ro_field_at_accessor(FIELD_T &field){
+    for_sequence<WIDTH>([&field](auto i) {
+        [[maybe_unused]] volatile uint32_t val = field.template at<i>();
+    });
+    [[maybe_unused]] volatile uint32_t val = field.template at<-1>().get();
+}
+
+template<typename FIELD_T, uint32_t WIDTH>
+void test_ro_field(FIELD_T &field){
+    [[maybe_unused]] volatile uint32_t read = field;
+    test_ro_field_at_accessor<FIELD_T, WIDTH>(field);
+}
+
+/****************************/
+/****** WO Field test *******/
+/****************************/
+
+template<typename FIELD_T, uint32_t WIDTH>
+void test_wo_field_at_accessor(FIELD_T &field){
+    for_sequence<WIDTH>([&field](auto i) {
+        field.template at<i>() = 1;
+    });
+    field.template at<-1>() = 0;
+}
+
+template<typename FIELD_T, uint32_t WIDTH>
+void test_wo_field(FIELD_T &field){
+    field = 1;
+    test_wo_field_at_accessor<FIELD_T, WIDTH>(field);
+}
+
+/****************************/
+/**** Generic Field test ****/
+/****************************/
+
+template<typename FIELD_T>
+void test_generic_field(FIELD_T &field,
+                        uint32_t width,
+                        size_t base_address,
+                        uint32_t start_bit,
+                        uint32_t end_bit,
+                        const char* field_path){
+
+    test_field_width(field, width, field_path);
+    test_field_base_address(field, base_address, field_path);
+    test_field_start_end_bit(field, start_bit, end_bit, field_path);
+
+}
+
+#endif