Initial Commit - Forked from PeakRDL-regblock @ a440cc19769069be831d267505da4f3789a26695

tests/lib/base_testcase.py

@@ -0,0 +1,140 @@
+from typing import Optional
+import unittest
+import os
+import glob
+import shutil
+import inspect
+import pathlib
+
+import pytest
+from systemrdl import RDLCompiler
+
+from peakrdl_regblock import RegblockExporter
+from peakrdl_regblock.udps import ALL_UDPS
+
+from .cpuifs.base import CpuifTestMode
+from .cpuifs.apb4 import APB4
+
+
+class BaseTestCase(unittest.TestCase):
+    #: Path to the testcase's RDL file.
+    #: Relative to the testcase's dir. If unset, the first RDL file found in the
+    #: testcase dir will be used
+    rdl_file = None # type: Optional[str]
+
+    #: RDL type name to elaborate. If unset, compiler will automatically choose
+    #: the top.
+    rdl_elab_target = None # type: Optional[str]
+
+    #: Parameters to pass into RDL elaboration
+    rdl_elab_params = {}
+
+    #: Define what CPUIF to use for this testcase
+    cpuif = APB4() # type: CpuifTestMode
+
+    # Other exporter args:
+    retime_read_fanin = False
+    retime_read_response = False
+    reuse_hwif_typedefs = True
+    retime_external = False
+    default_reset_activelow = False
+    default_reset_async = False
+
+    #: this gets auto-loaded via the _load_request autouse fixture
+    request = None # type: pytest.FixtureRequest
+
+    exporter = RegblockExporter()
+
+    @pytest.fixture(autouse=True)
+    def _load_request(self, request):
+        self.request = request
+
+    @property
+    def rerun(self) -> bool:
+        """
+        Re-run without deleting and re-generating prior output directory.
+        """
+        return self.request.config.getoption("--rerun")
+
+    def get_testcase_dir(self) -> str:
+        class_dir = os.path.dirname(inspect.getfile(self.__class__))
+        return class_dir
+
+    def get_run_dir(self) -> str:
+        this_dir = self.get_testcase_dir()
+        run_dir = os.path.join(this_dir, "run.out", self.__class__.__name__)
+        return run_dir
+
+    def _write_params(self) -> None:
+        """
+        Write out the class parameters to a file so that it is easier to debug
+        how a testcase was parameterized
+        """
+        path = os.path.join(self.get_run_dir(), "params.txt")
+
+        with open(path, 'w') as f:
+            for k, v in self.__class__.__dict__.items():
+                if k.startswith("_") or callable(v):
+                    continue
+                f.write(f"{k}: {repr(v)}\n")
+
+
+    def export_regblock(self):
+        """
+        Call the peakrdl_regblock exporter to generate the DUT
+        """
+        this_dir = self.get_testcase_dir()
+
+        if self.rdl_file:
+            rdl_file = os.path.join(this_dir, self.rdl_file)
+        else:
+            # Find any *.rdl file in testcase dir
+            rdl_file = glob.glob(os.path.join(this_dir, "*.rdl"))[0]
+
+        rdlc = RDLCompiler()
+
+        # Load the UDPs
+        for udp in ALL_UDPS:
+            rdlc.register_udp(udp)
+        # ... including the definition
+        udp_file = os.path.join(this_dir, "../../hdl-src/regblock_udps.rdl")
+        rdlc.compile_file(udp_file)
+
+        rdlc.compile_file(rdl_file)
+        root = rdlc.elaborate(self.rdl_elab_target, "regblock", self.rdl_elab_params)
+
+        self.exporter.export(
+            root,
+            self.get_run_dir(),
+            module_name="regblock",
+            package_name="regblock_pkg",
+            cpuif_cls=self.cpuif.cpuif_cls,
+            retime_read_fanin=self.retime_read_fanin,
+            retime_read_response=self.retime_read_response,
+            reuse_hwif_typedefs=self.reuse_hwif_typedefs,
+            retime_external_reg=self.retime_external,
+            retime_external_regfile=self.retime_external,
+            retime_external_mem=self.retime_external,
+            retime_external_addrmap=self.retime_external,
+            default_reset_activelow=self.default_reset_activelow,
+            default_reset_async=self.default_reset_async,
+        )
+
+    def delete_run_dir(self) -> None:
+        run_dir = self.get_run_dir()
+        if os.path.exists(run_dir):
+            shutil.rmtree(run_dir)
+
+    def setUp(self) -> None:
+        if self.rerun:
+            return
+
+        # Create fresh build dir
+        run_dir = self.get_run_dir()
+        self.delete_run_dir()
+        pathlib.Path(run_dir).mkdir(parents=True, exist_ok=True)
+
+        self._write_params()
+
+        # Convert testcase RDL file --> SV
+        self.export_regblock()