Add testcases to cover design validation errors

tests/test_validation_errors/external_ref.rdl

@@ -0,0 +1,15 @@
+addrmap sub {
+    reg {
+        field {} f;
+    } x;
+};
+
+addrmap top {
+    reg {
+        field {} f;
+    } x;
+
+    sub sub;
+
+    x.f->reset = sub.x.f;
+};

tests/test_validation_errors/inconsistent_accesswidth.rdl

@@ -0,0 +1,9 @@
+addrmap top {
+    reg {
+        field {}f;
+    } x;
+    reg {
+        accesswidth = 16;
+        field {}f;
+    } y;
+};

tests/test_validation_errors/multiple_unconditional_assigns.rdl

@@ -0,0 +1,40 @@
+addrmap top {
+    reg {
+        field {
+            sw = rw;
+            hw = w;
+            singlepulse = true;
+        } a = 0;
+        field {
+            sw = rw;
+            hw = w;
+            singlepulse = true;
+            posedge intr;
+            stickybit = false;
+        } b = 0;
+        field {
+            sw = rw;
+            hw = w;
+            singlepulse = true;
+            negedge intr;
+            stickybit = false;
+        } c = 0;
+        field {
+            sw = rw;
+            hw = w;
+            singlepulse = true;
+            bothedge intr;
+            stickybit = false;
+        } d = 0;
+    } x;
+};
+
+/*
+stickybit=false + intr posedge
+stickybit=false + intr negedge
+stickybit=false + intr bothedge
+hw=w wel = false
+singlepulse
+
+
+*/

tests/test_validation_errors/sharedextbus.rdl

@@ -0,0 +1,7 @@
+addrmap top {
+    sharedextbus;
+
+    reg {
+        field {}f;
+    } x;
+};

tests/test_validation_errors/testcase.py

@@ -0,0 +1,78 @@
+import io
+import contextlib
+
+from systemrdl.messages import RDLCompileError
+
+from ..lib.base_testcase import BaseTestCase
+
+class TestValidationErrors(BaseTestCase):
+    def setUp(self) -> None:
+        # Stub usual pre-test setup
+        pass
+
+    def tearDown(self):
+        # Delete any cruft that may get generated
+        self.delete_run_dir()
+
+    def assert_validate_error(self, rdl_file: str, err_regex: str) -> None:
+        self.rdl_file = rdl_file
+        f = io.StringIO()
+        with contextlib.redirect_stderr(f):
+            with self.assertRaises(RDLCompileError):
+                self.export_regblock()
+        stderr = f.getvalue()
+        self.assertRegex(stderr, err_regex)
+
+
+    def test_unaligned_reg(self) -> None:
+        self.assert_validate_error(
+            "unaligned_reg.rdl",
+            "Unaligned registers are not supported. Address offset of instance 'x' must be a multiple of 4",
+        )
+
+    def test_unaligned_stride(self) -> None:
+        self.assert_validate_error(
+            "unaligned_stride.rdl",
+            "Unaligned registers are not supported. Address stride of instance array 'x' must be a multiple of 4",
+        )
+
+    def test_bad_external_ref(self) -> None:
+        self.assert_validate_error(
+            "external_ref.rdl",
+            "Property is assigned a reference that points to a component not internal to the regblock being exported",
+        )
+
+    def test_sharedextbus_not_supported(self) -> None:
+        self.assert_validate_error(
+            "sharedextbus.rdl",
+            "This exporter does not support enabling the 'sharedextbus' property yet",
+        )
+
+    def test_inconsistent_accesswidth(self) -> None:
+        self.assert_validate_error(
+            "inconsistent_accesswidth.rdl",
+            r"Multi-word registers that have an accesswidth \(16\) that are inconsistent with this regblock's CPU bus width \(32\) are not supported",
+        )
+
+    def test_unbuffered_wide_w_fields(self) -> None:
+        self.assert_validate_error(
+            "unbuffered_wide_fields.rdl",
+            "Software-writable field 'xf' shall not span"
+            " multiple software-accessible subwords. Consider enabling"
+            " write double-buffering",
+        )
+
+    def test_unbuffered_wide_r_fields(self) -> None:
+        self.assert_validate_error(
+            "unbuffered_wide_fields.rdl",
+            "The field 'yf' spans multiple software-accessible"
+            " subwords and is modified on-read, making it impossible to"
+            " access its value correctly. Consider enabling read"
+            " double-buffering.",
+        )
+
+    def test_multiple_unconditional_assigns(self) -> None:
+        self.assert_validate_error(
+            "multiple_unconditional_assigns.rdl",
+            "Field has multiple conflicting properties that unconditionally set its state",
+        )

tests/test_validation_errors/unaligned_reg.rdl

@@ -0,0 +1,8 @@
+addrmap top {
+    default regwidth = 32;
+    default accesswidth = 32;
+
+    reg {
+        field {}f;
+    } x @ 1;
+};

tests/test_validation_errors/unaligned_stride.rdl

@@ -0,0 +1,8 @@
+addrmap top {
+    default regwidth = 32;
+    default accesswidth = 32;
+
+    reg {
+        field {}f;
+    } x[4] @ 0 += 5;
+};

tests/test_validation_errors/unbuffered_wide_fields.rdl

@@ -0,0 +1,21 @@
+addrmap top {
+    reg {
+        regwidth = 64;
+        accesswidth = 32;
+        field {
+            sw=w;
+            hw=r;
+        } xf[64];
+    } x;
+
+    reg {
+        regwidth = 64;
+        accesswidth = 32;
+        field {
+            sw=r;
+            hw=w;
+            we;
+            onread=rclr;
+        } yf[64];
+    } y;
+};