remove classes

micromagnetictests/calculatortests/__init__.py

@@ -1,42 +1,55 @@
-"""Calculator tests"""
+"""Calculator tests."""
 
-from .compute import TestCompute as TestCompute
-from .cubicanisotropy import TestCubicAnisotropy as TestCubicAnisotropy
-from .damping import TestDamping as TestDamping
-from .demag import TestDemag as TestDemag
-from .dirname import test_dirname as test_dirname
-from .dmi import TestDMI as TestDMI
-from .dynamics import TestDynamics as TestDynamics
-from .energy import TestEnergy as TestEnergy
-from .exchange import TestExchange as TestExchange
-from .fixedsubregions import TestFixedSubregions as TestFixedSubregions
-from .hysteresisdriver import Ms as Ms
-from .hysteresisdriver import system as system
-from .hysteresisdriver import (
-    test_hysteresis_check_for_energy as test_hysteresis_check_for_energy,
-)
-from .hysteresisdriver import test_simple_hysteresis_loop as test_simple_hysteresis_loop
-from .hysteresisdriver import (
-    test_stepped_hysteresis_loop as test_stepped_hysteresis_loop,
+from importlib import import_module
+
+_MODULES = (
+    "compute",
+    "cubicanisotropy",
+    "damping",
+    "demag",
+    "dirname",
+    "dmi",
+    "dynamics",
+    "energy",
+    "exchange",
+    "fixedsubregions",
+    "hysteresisdriver",
+    "info_file",
+    "mesh",
+    "mindriver",
+    "multiple_drives",
+    "outputformat",
+    "outputstep",
+    "precession",
+    "relaxdriver",
+    "rkky",
+    "schedule",
+    "skyrmion",
+    "slonczewski",
+    "stdprob3",
+    "stdprob4",
+    "stdprob5",
+    "threads",
+    "timedriver",
+    "uniaxialanisotropy",
+    "zeeman",
+    "zhangli",
 )
-from .info_file import test_info_file as test_info_file
-from .mesh import TestMesh as TestMesh
-from .mindriver import TestMinDriver as TestMinDriver
-from .multiple_drives import test_multiple_drives as test_multiple_drives
-from .outputformat import test_format as test_format
-from .outputstep import test_outputstep as test_outputstep
-from .precession import TestPrecession as TestPrecession
-from .relaxdriver import test_relax_check_for_energy as test_relax_check_for_energy
-from .relaxdriver import test_relaxdriver as test_relaxdriver
-from .rkky import TestRKKY as TestRKKY
-from .schedule import test_schedule as test_schedule
-from .skyrmion import test_skyrmion as test_skyrmion
-from .slonczewski import TestSlonczewski as TestSlonczewski
-from .stdprob3 import test_stdprob3 as test_stdprob3
-from .stdprob4 import test_stdprob4 as test_stdprob4
-from .stdprob5 import test_stdprob5 as test_stdprob5
-from .threads import TestThreads as TestThreads
-from .timedriver import TestTimeDriver as TestTimeDriver
-from .uniaxialanisotropy import TestUniaxialAnisotropy as TestUniaxialAnisotropy
-from .zeeman import TestZeeman as TestZeeman
-from .zhangli import TestZhangLi as TestZhangLi
+
+
+def _is_test_or_fixture(name, obj):
+    return name.startswith("test_") or hasattr(obj, "_fixture_function_marker")
+
+
+for _module_name in _MODULES:
+    _module = import_module(f"{__name__}.{_module_name}")
+    globals().update(
+        {
+            name: obj
+            for name, obj in vars(_module).items()
+            if _is_test_or_fixture(name, obj)
+        }
+    )
+    globals().pop(_module_name, None)
+
+del import_module, _is_test_or_fixture, _module, _module_name

micromagnetictests/calculatortests/compute.py

@@ -1,112 +1,144 @@
 import sys
+from types import SimpleNamespace
 
 import discretisedfield as df
 import micromagneticmodel as mm
 import pytest
 
 
-class TestCompute:
-    @pytest.fixture(autouse=True)
-    def _setup_calculator(self, calculator):
-        self.calculator = calculator
-
-    def setup_method(self):
-        name = "compute_tests"
-        p1 = (0, 0, 0)
-        p2 = (10e-9, 2e-9, 2e-9)
-        cell = (2e-9, 2e-9, 2e-9)
-        region = df.Region(p1=p1, p2=p2)
-        subregions = {
-            "a": df.Region(p1=(0, 0, 0), p2=(6e-9, 2e-9, 2e-9)),
-            "b": df.Region(p1=(6e-9, 0, 0), p2=(10e-9, 2e-9, 2e-9)),
-        }
-        mesh = df.Mesh(region=region, cell=cell, subregions=subregions)
-        self.subregions = subregions
-        self.system = mm.System(name=name)
-        self.system.energy = (
-            mm.Exchange(A=1e-12)
-            + mm.Demag()
-            + mm.Zeeman(H=(8e6, 0, 0))
-            + mm.UniaxialAnisotropy(K=1e4, u=(0, 0, 1))
-            + mm.CubicAnisotropy(K=1e3, u1=(1, 0, 0), u2=(0, 1, 0))
-        )
+@pytest.fixture
+def compute_case(calculator):
+    case = SimpleNamespace()
+    case.calculator = calculator
+    name = "compute_tests"
+    p1 = (0, 0, 0)
+    p2 = (10e-9, 2e-9, 2e-9)
+    cell = (2e-9, 2e-9, 2e-9)
+    region = df.Region(p1=p1, p2=p2)
+    subregions = {
+        "a": df.Region(p1=(0, 0, 0), p2=(6e-9, 2e-9, 2e-9)),
+        "b": df.Region(p1=(6e-9, 0, 0), p2=(10e-9, 2e-9, 2e-9)),
+    }
+    mesh = df.Mesh(region=region, cell=cell, subregions=subregions)
+    case.subregions = subregions
+    case.system = mm.System(name=name)
+    case.system.energy = (
+        mm.Exchange(A=1e-12)
+        + mm.Demag()
+        + mm.Zeeman(H=(8e6, 0, 0))
+        + mm.UniaxialAnisotropy(K=1e4, u=(0, 0, 1))
+        + mm.CubicAnisotropy(K=1e3, u1=(1, 0, 0), u2=(0, 1, 0))
+    )
+
+    case.system.m = df.Field(mesh, nvdim=3, value=(0, 0, 1), norm=8e6)
+
+    return case
 
-        self.system.m = df.Field(mesh, nvdim=3, value=(0, 0, 1), norm=8e6)
 
-    def test_energy(self):
-        for term in self.system.energy:
-            assert isinstance(self.calculator.compute(term.energy, self.system), float)
+def test_compute_energy(compute_case):
+    for term in compute_case.system.energy:
         assert isinstance(
-            self.calculator.compute(self.system.energy.energy, self.system), float
+            compute_case.calculator.compute(term.energy, compute_case.system), float
         )
-        self.calculator.delete(self.system)
+    assert isinstance(
+        compute_case.calculator.compute(
+            compute_case.system.energy.energy, compute_case.system
+        ),
+        float,
+    )
+    compute_case.calculator.delete(compute_case.system)
 
-    def test_energy_density(self):
-        for term in self.system.energy:
-            e_density = self.calculator.compute(term.density, self.system)
-            assert isinstance(e_density, df.Field)
-            assert e_density.mesh.subregions == self.subregions
-        e_density = self.calculator.compute(self.system.energy.density, self.system)
+
+def test_compute_energy_density(compute_case):
+    for term in compute_case.system.energy:
+        e_density = compute_case.calculator.compute(term.density, compute_case.system)
         assert isinstance(e_density, df.Field)
-        assert e_density.mesh.subregions == self.subregions
-        self.calculator.delete(self.system)
+        assert e_density.mesh.subregions == compute_case.subregions
+    e_density = compute_case.calculator.compute(
+        compute_case.system.energy.density, compute_case.system
+    )
+    assert isinstance(e_density, df.Field)
+    assert e_density.mesh.subregions == compute_case.subregions
+    compute_case.calculator.delete(compute_case.system)
 
-    def test_effective_field(self):
-        for term in self.system.energy:
-            effective_field = self.calculator.compute(term.effective_field, self.system)
-            assert isinstance(effective_field, df.Field)
-            assert effective_field.mesh.subregions == self.subregions
-        effective_field = self.calculator.compute(
-            self.system.energy.effective_field, self.system
+
+def test_compute_effective_field(compute_case):
+    for term in compute_case.system.energy:
+        effective_field = compute_case.calculator.compute(
+            term.effective_field, compute_case.system
         )
         assert isinstance(effective_field, df.Field)
-        assert effective_field.mesh.subregions == self.subregions
-        self.calculator.delete(self.system)
-
-    def test_invalid_func(self):
-        with pytest.raises(ValueError):
-            self.calculator.compute(self.system.energy.__len__, self.system)
-
-    def test_dmi(self):
-        if sys.platform != "win32":
-            self.system.energy += mm.DMI(D=5e-3, crystalclass="T")
-            term = self.system.energy.dmi
-            for crystalclass in [
-                "T",
-                "Cnv_x",
-                "Cnv_y",
-                "Cnv_z",
-                "D2d_x",
-                "D2d_y",
-                "D2d_z",
-            ]:
-                term.crystalclass = crystalclass
-                assert isinstance(
-                    self.calculator.compute(term.energy, self.system), float
-                )
-                e_density = self.calculator.compute(term.density, self.system)
-                assert isinstance(e_density, df.Field)
-                assert e_density.mesh.subregions == self.subregions
-                effective_field = self.calculator.compute(
-                    term.effective_field, self.system
-                )
-                assert isinstance(effective_field, df.Field)
-                assert effective_field.mesh.subregions == self.subregions
-            assert isinstance(
-                self.calculator.compute(self.system.energy.energy, self.system), float
-            )
-            self.calculator.delete(self.system)
+        assert effective_field.mesh.subregions == compute_case.subregions
+    effective_field = compute_case.calculator.compute(
+        compute_case.system.energy.effective_field, compute_case.system
+    )
+    assert isinstance(effective_field, df.Field)
+    assert effective_field.mesh.subregions == compute_case.subregions
+    compute_case.calculator.delete(compute_case.system)
 
-    def test_slonczewski(self):
-        self.system.dynamics = mm.Slonczewski(J=7.5e12, mp=(1, 0, 0), P=0.4, Lambda=2)
-        assert isinstance(
-            self.calculator.compute(self.system.energy.energy, self.system), float
+
+def test_compute_invalid_func(compute_case):
+    with pytest.raises(ValueError):
+        compute_case.calculator.compute(
+            compute_case.system.energy.__len__, compute_case.system
         )
-        self.calculator.delete(self.system)
 
-    def test_zhang_li(self):
-        self.system.dynamics = mm.ZhangLi(beta=0.01, u=5e6)
+
+def test_compute_dmi(compute_case):
+    if sys.platform != "win32":
+        compute_case.system.energy += mm.DMI(D=5e-3, crystalclass="T")
+        term = compute_case.system.energy.dmi
+        for crystalclass in [
+            "T",
+            "Cnv_x",
+            "Cnv_y",
+            "Cnv_z",
+            "D2d_x",
+            "D2d_y",
+            "D2d_z",
+        ]:
+            term.crystalclass = crystalclass
+            assert isinstance(
+                compute_case.calculator.compute(term.energy, compute_case.system), float
+            )
+            e_density = compute_case.calculator.compute(
+                term.density, compute_case.system
+            )
+            assert isinstance(e_density, df.Field)
+            assert e_density.mesh.subregions == compute_case.subregions
+            effective_field = compute_case.calculator.compute(
+                term.effective_field, compute_case.system
+            )
+            assert isinstance(effective_field, df.Field)
+            assert effective_field.mesh.subregions == compute_case.subregions
         assert isinstance(
-            self.calculator.compute(self.system.energy.energy, self.system), float
+            compute_case.calculator.compute(
+                compute_case.system.energy.energy, compute_case.system
+            ),
+            float,
         )
-        self.calculator.delete(self.system)
+        compute_case.calculator.delete(compute_case.system)
+
+
+def test_compute_slonczewski(compute_case):
+    compute_case.system.dynamics = mm.Slonczewski(
+        J=7.5e12, mp=(1, 0, 0), P=0.4, Lambda=2
+    )
+    assert isinstance(
+        compute_case.calculator.compute(
+            compute_case.system.energy.energy, compute_case.system
+        ),
+        float,
+    )
+    compute_case.calculator.delete(compute_case.system)
+
+
+def test_compute_zhang_li(compute_case):
+    compute_case.system.dynamics = mm.ZhangLi(beta=0.01, u=5e6)
+    assert isinstance(
+        compute_case.calculator.compute(
+            compute_case.system.energy.energy, compute_case.system
+        ),
+        float,
+    )
+    compute_case.calculator.delete(compute_case.system)