Refactor reframe tests to use new base classes

reframe_tests/base_tests.py

@@ -118,6 +118,11 @@ class GprMaxRegressionTest(rfm.RunOnlyRegressionTest):
         path_to_pyenv = os.path.join(CreatePyenvTest(part="login").stagedir, PATH_TO_PYENV)
         self.prerun_cmds.append(f"source {path_to_pyenv}")
 
+    @run_after("init")
+    def set_model(self):
+        if hasattr(self, "models") and self.models is not None:
+            self.model = self.models
+
     @run_after("init", always_last=True)
     def configure_test_run(self, input_file_ext: str = ".in"):
         self.input_file = f"{self.model}{input_file_ext}"
@@ -259,7 +264,7 @@ class GprMaxBScanRegressionTest(GprMaxRegressionTest):
 
 
 class GprMaxTaskfarmRegressionTest(GprMaxBScanRegressionTest):
-    serial_dependecy = variable(type[GprMaxRegressionTest])
+    serial_dependency = variable(type[GprMaxRegressionTest])
     extra_executable_opts = ["-taskfarm"]
 
     num_tasks = required
@@ -267,25 +272,25 @@ class GprMaxTaskfarmRegressionTest(GprMaxBScanRegressionTest):
     @run_after("init")
     def inject_dependencies(self):
         """Test depends on the Python virtual environment building correctly"""
-        variant = self.serial_dependecy.get_variant_nums(
+        variant = self.serial_dependency.get_variant_nums(
             model=lambda m: m == self.model, num_models=lambda n: n == self.num_models
         )
-        self.depends_on(self.serial_dependecy.variant_name(variant[0]), udeps.by_env)
+        self.depends_on(self.serial_dependency.variant_name(variant[0]), udeps.by_env)
         super().inject_dependencies()
 
     @run_before("run")
     def setup_reference_file(self):
         """Add prerun command to load the built Python environment"""
-        variant = self.serial_dependecy.get_variant_nums(
+        variant = self.serial_dependency.get_variant_nums(
             model=lambda m: m == self.model, num_models=lambda n: n == self.num_models
         )
-        target = self.getdep(self.serial_dependecy.variant_name(variant[0]))
+        target = self.getdep(self.serial_dependency.variant_name(variant[0]))
         self.reference_file = os.path.join(target.stagedir, str(self.output_file))
 
 
 class GprMaxMPIRegressionTest(GprMaxRegressionTest):
     mpi_layout = variable(typ.List[int])
-    serial_dependecy = variable(type[GprMaxRegressionTest])
+    serial_dependency = variable(type[GprMaxRegressionTest])
 
     @run_after("init", always_last=True)
     def configure_test_run(self):
@@ -296,13 +301,13 @@ class GprMaxMPIRegressionTest(GprMaxRegressionTest):
     @run_after("init")
     def inject_dependencies(self):
         """Test depends on the Python virtual environment building correctly"""
-        variant = self.serial_dependecy.get_variant_nums(model=lambda m: m == self.model)
+        variant = self.serial_dependency.get_variant_nums(model=lambda m: m == self.model)
-        self.depends_on(self.serial_dependecy.variant_name(variant[0]), udeps.by_env)
+        self.depends_on(self.serial_dependency.variant_name(variant[0]), udeps.by_env)
         super().inject_dependencies()
 
     @run_before("run")
     def setup_reference_file(self):
         """Add prerun command to load the built Python environment"""
-        variant = self.serial_dependecy.get_variant_nums(model=lambda m: m == self.model)
+        variant = self.serial_dependency.get_variant_nums(model=lambda m: m == self.model)
-        target = self.getdep(self.serial_dependecy.variant_name(variant[0]))
+        target = self.getdep(self.serial_dependency.variant_name(variant[0]))
         self.reference_file = os.path.join(target.stagedir, str(self.output_file))

reframe_tests/reframe_tests.py

@@ -6,7 +6,7 @@ from base_tests import (
     GprMaxRegressionTest,
     GprMaxTaskfarmRegressionTest,
 )
-from reframe.core.builtins import parameter, run_after
+from reframe.core.builtins import parameter, run_after, skip
 
 """ReFrame tests for basic functionality
 
@@ -16,136 +16,228 @@ from reframe.core.builtins import parameter, run_after
 """
 
 
+class TestAscan(GprMaxRegressionTest):
+    tags = {
+        "test",
+        "serial",
+        "ascan",
+        "2d",
+        "hertzian_dipole",
+        "waveform",
+        "material",
+        "box",
+        "cylinder",
+    }
+    model = "cylinder_Ascan_2D"
+
+
 @rfm.simple_test
 class TestBscan(GprMaxBScanRegressionTest):
-    tags = {"test", "bscan"}
+    tags = {
-
+        "test",
+        "serial",
+        "bscan",
+        "steps",
+        "waveform",
+        "hertzian_dipole",
+        "material",
+        "box",
+        "cylinder",
+    }
     model = "cylinder_Bscan_2D"
     num_models = 64
 
 
 @rfm.simple_test
 class TestSingleNodeTaskfarm(GprMaxTaskfarmRegressionTest):
-    tags = {"test", "mpi", "taskfarm"}
+    tags = {
-
+        "test",
+        "mpi",
+        "taskfarm",
+        "steps",
+        "waveform",
+        "hertzian_dipole",
+        "material",
+        "box",
+        "cylinder",
+    }
     model = "cylinder_Bscan_2D"
     num_tasks = 8
     num_tasks_per_node = 8
     num_models = 64
-    serial_dependecy = TestBscan
+    serial_dependency = TestBscan
 
 
 @rfm.simple_test
 class TestMultiNodeTaskfarm(GprMaxTaskfarmRegressionTest):
-    tags = {"test", "mpi", "taskfarm"}
+    tags = {
-
+        "test",
+        "mpi",
+        "taskfarm",
+        "steps",
+        "waveform",
+        "hertzian_dipole",
+        "material",
+        "box",
+        "cylinder",
+    }
     model = "cylinder_Bscan_2D"
     num_tasks = 32
     num_tasks_per_node = 8
     num_models = 64
-    serial_dependecy = TestBscan
+    serial_dependency = TestBscan
 
 
 @rfm.simple_test
 class Test2DModelXY(GprMaxRegressionTest):
-    tags = {"test", "serial", "2d"}
+    tags = {"test", "serial", "2d", "waveform", "hertzian_dipole"}
-
     model = "2D_EzHxHy"
 
 
+@rfm.simple_test
+class Test2DModelXZ(GprMaxRegressionTest):
+    tags = {"test", "serial", "2d", "waveform", "hertzian_dipole"}
+    model = "2D_EyzHxHz"
+
+
 @rfm.simple_test
 class Test2DModelYZ(GprMaxRegressionTest):
-    tags = {"test", "serial", "2d"}
+    tags = {"test", "serial", "2d", "waveform", "hertzian_dipole"}
-
+    model = "2D_ExzHyHz"
-    model = "2D_EzHxHy"
 
 
 @rfm.simple_test
-class BasicModelsTest(GprMaxRegressionTest):
+class TestHertzianDipoleSource(GprMaxRegressionTest):
-    tags = {"test", "serial", "regression"}
+    tags = {"test", "serial", "hertzian_dipole", "waveform"}
-
+    model = "hertzian_dipole_fs"
-    def __init__(self):
-        super().__init__()
-        # List of available basic test models
-        self.model = parameter(
-            [
-                "2D_ExHyHz",
-                "2D_EyHxHz",
-                "2D_EzHxHy",
-                "2D_ExHyHz_hs",
-                "cylinder_Ascan_2D",
-                "hertzian_dipole_fs",
-                "hertzian_dipole_hs",
-                "hertzian_dipole_dispersive",
-                "magnetic_dipole_fs",
-                "magnetic_dipole_hs",
-            ]
-        )
 
 
 @rfm.simple_test
-class AntennaModelsTest(GprMaxRegressionTest):
+class TestMagneticDipoleSource(GprMaxRegressionTest):
-    tags = {"test", "serial", "regression", "antenna"}
+    tags = {"test", "serial", "magnetic_dipole", "waveform"}
+    model = "magnetic_dipole_fs"
 
-    # List of available antenna test models
+
+@rfm.simple_test
+class TestDispersiveMaterials(GprMaxRegressionTest):
+    tags = {"test", "serial", "hertzian_dipole", "waveform", "material", "dispersive", "box"}
+    model = "hertizian_dipole_dispersive"
+
+
+@rfm.simple_test
+class TestTransmissionLineSource(GprMaxRegressionTest):
+    tags = {"test", "serial", "transmission_line", "waveform"}
+    model = "transmission_line_fs"
+
+
+@rfm.simple_test
+class TestEdgeGeometry(GprMaxRegressionTest):
+    tags = {"test", "serial", "geometry", "edge", "transmission_line", "waveform", "antenna"}
     model = "antenna_wire_dipole_fs"
 
 
 @rfm.simple_test
-class SubgridTest(GprMaxAPIRegressionTest):
+class TestSubgrids(GprMaxAPIRegressionTest):
-    tags = {"test", "api", "serial", "regression", "subgrid"}
+    tags = {
-
+        "test",
-    def __init__(self):
+        "api",
-        super().__init__()
+        "serial",
-        # List of available subgrid test models
+        "subgrid",
-        self.model = parameter(
+        "hertzian_dipole",
-            [
+        "waveform",
-                "cylinder_fs",
+        "material",
-                # "gssi_400_over_fractal_subsurface",  # Takes ~1hr 30m on ARCHER2
+        "dispersive",
-            ]
+        "cylinder",
-        )
+    }
+    model = "cylinder_fs"
 
 
 @rfm.simple_test
-class MPIBasicModelsTest(GprMaxMPIRegressionTest):
+@skip("Takes ~1hr 30m on ARCHER2")
-    tags = {"test", "mpi", "regression"}
+class TestSubgridsWithAntennaModel(GprMaxAPIRegressionTest):
+    tags = {
+        "test",
+        "api",
+        "serial",
+        "subgrid",
+        "antenna",
+        "material",
+        "box",
+        "fractal_box",
+        "add_surface_roughness",
+    }
+    model = "gssi_400_over_fractal_subsurface"
 
-    num_tasks_per_node = 4
-    mpi_layout = [2, 2, 2]
 
-    serial_dependency = BasicModelsTest
+@rfm.simple_test
+class Test2DModelXYMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "2d", "waveform", "hertzian_dipole"}
+    model = "2D_EzHxHy"
+    mpi_layout = [4, 4, 1]
+    serial_dependency = Test2DModelXY
 
-    def __init__(self):
+
-        super().__init__()
+@rfm.simple_test
-        # List of available basic test models
+class Test2DModelXZMpi(GprMaxMPIRegressionTest):
-        self.model = parameter(
+    tags = {"test", "mpi", "2d", "waveform", "hertzian_dipole"}
-            [
+    model = "2D_EyzHxHz"
-                "2D_ExHyHz",
+    mpi_layout = [4, 1, 4]
-                "2D_EyHxHz",
+    serial_dependency = Test2DModelXZ
-                "2D_EzHxHy",
+
-                "2D_ExHyHz_hs",
+
-                "cylinder_Ascan_2D",
+@rfm.simple_test
-                "hertzian_dipole_fs",
+class Test2DModelYZMpi(GprMaxMPIRegressionTest):
-                "hertzian_dipole_hs",
+    tags = {"test", "mpi", "2d", "waveform", "hertzian_dipole"}
-                "hertzian_dipole_dispersive",
+    model = "2D_ExzHyHz"
-                "magnetic_dipole_fs",
+    mpi_layout = [1, 4, 4]
-                "magnetic_dipole_hs",
+    serial_dependency = Test2DModelYZ
-            ]
+
-        )
+
+@rfm.simple_test
+class TestHertzianDipoleSourceMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "hertzian_dipole", "waveform"}
+    model = "hertzian_dipole_fs"
+    mpi_layout = [3, 3, 3]
+    serial_dependency = TestHertzianDipoleSource
+
+
+@rfm.simple_test
+class TestMagneticDipoleSourceMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "magnetic_dipole", "waveform"}
+    model = "magnetic_dipole_fs"
+    mpi_layout = [3, 3, 3]
+    serial_dependency = TestMagneticDipoleSource
+
+
+@rfm.simple_test
+class TestDispersiveMaterialsMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "hertzian_dipole", "waveform", "material", "dispersive", "box"}
+    model = "hertizian_dipole_dispersive"
+    mpi_layout = [3, 3, 3]
+    serial_dependency = TestDispersiveMaterials
+
+
+@rfm.simple_test
+class TestTransmissionLineSourceMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "transmission_line", "waveform"}
+    model = "transmission_line_fs"
+    mpi_layout = [3, 3, 3]
+    serial_dependency = TestTransmissionLineSource
+
+
+@rfm.simple_test
+class TestEdgeGeometryMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "geometry", "edge", "transmission_line", "waveform", "antenna"}
+    model = "antenna_wire_dipole_fs"
+    mpi_layout = [3, 3, 3]
+    serial_dependency = TestEdgeGeometry
 
 
 @rfm.simple_test
 class TestBoxGeometryNoPml(GprMaxRegressionTest):
+    tags = {"test", "serial", "geometery", "box"}
     sourcesdir = "src/box_geometry_tests"
-
+    models = parameter(["box_full_model", "box_half_model"])
-    def __init__(self):
-        super().__init__()
-        self.model = parameter(
-            [
-                "box_full_model",
-                "box_half_model",
-            ]
-        )
 
     @run_after("init", always_last=True)
     def add_gprmax_commands(self):
@@ -154,33 +246,18 @@ class TestBoxGeometryNoPml(GprMaxRegressionTest):
 
 @rfm.simple_test
 class TestBoxGeometryDefaultPml(GprMaxRegressionTest):
+    tags = {"test", "serial", "geometery", "box"}
     sourcesdir = "src/box_geometry_tests"
-
+    models = parameter(["box_full_model", "box_half_model"])
-    def __init__(self):
-        super().__init__()
-        self.model = parameter(
-            [
-                "box_full_model",
-                "box_half_model",
-            ]
-        )
 
 
 @rfm.simple_test
 class TestBoxGeometryNoPmlMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "geometery", "box"}
+    models = TestBoxGeometryNoPml.models
     mpi_layout = [2, 2, 2]
-
     serial_dependency = TestBoxGeometryNoPml
 
-    def __init__(self):
-        super().__init__()
-        self.model = parameter(
-            [
-                "box_full_model",
-                "box_half_model",
-            ]
-        )
-
     @run_after("init", always_last=True)
     def add_gprmax_commands(self):
         self.prerun_cmds.append(f"echo '#pml_cells: 0' >> {self.input_file}")
@@ -188,15 +265,7 @@ class TestBoxGeometryNoPmlMpi(GprMaxMPIRegressionTest):
 
 @rfm.simple_test
 class TestBoxGeometryDefaultPmlMpi(GprMaxMPIRegressionTest):
+    tags = {"test", "mpi", "geometery", "box"}
+    models = TestBoxGeometryDefaultPml.models
     mpi_layout = [2, 2, 2]
-
     serial_dependency = TestBoxGeometryDefaultPml
-
-    def __init__(self):
-        super().__init__()
-        self.model = parameter(
-            [
-                "box_full_model",
-                "box_half_model",
-            ]
-        )