Add behavioral tests for SimulationCorrected and degenerate GMM (#150)

SimulationCorrected: test delay computation from mocked arrival
times, fallback on simulation failure, and fallback when k-wave
is missing. ThresholdMRI: test that near-constant brain intensity
falls back to gray_matter instead of collapsing to all-CSF.

Author: Brandon Kirkland

tests/test_simulation_corrected.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from unittest.mock import patch
+
+import numpy as np
 import pytest
 
 from openlifu.bf.delay_methods import DelayMethod, SimulationCorrected
@@ -126,3 +129,58 @@ def test_to_table(self):
         assert table.iloc[0]['Value'] == 'SimulationCorrected'
         assert table.iloc[1]['Name'] == 'Default Sound Speed'
         assert table.iloc[1]['Value'] == 1500.0
+
+
+class TestSimulationCorrectedBehavior:
+    """Test delay calculation logic by mocking the k-wave simulation layer."""
+
+    def test_delays_from_known_arrival_times(self):
+        """When _run_reciprocal_simulation returns known arrival times,
+        calc_delays should return max(arrival) - arrival for each element."""
+        arrival_times = np.array([0.001, 0.002, 0.003])
+        expected_delays = np.array([0.002, 0.001, 0.0])
+
+        method = SimulationCorrected()
+        with patch.object(
+            SimulationCorrected,
+            "_run_reciprocal_simulation",
+            return_value=arrival_times,
+        ), patch("importlib.util.find_spec", return_value=True):
+            delays = method.calc_delays(
+                arr=None, target=None, params=None, transform=None
+            )
+        np.testing.assert_allclose(delays, expected_delays)
+
+    def test_fallback_on_simulation_failure(self):
+        """When _run_reciprocal_simulation raises, calc_delays should
+        fall back to Direct geometric delays without crashing."""
+        method = SimulationCorrected()
+        with patch.object(
+            SimulationCorrected,
+            "_run_reciprocal_simulation",
+            side_effect=RuntimeError("mocked failure"),
+        ), patch("importlib.util.find_spec", return_value=True), patch.object(
+            SimulationCorrected,
+            "_fallback_delays",
+            return_value=np.array([0.0, 0.0, 0.0]),
+        ) as mock_fallback:
+            delays = method.calc_delays(
+                arr=None, target=None, params=None, transform=None
+            )
+        mock_fallback.assert_called_once()
+        np.testing.assert_array_equal(delays, [0.0, 0.0, 0.0])
+
+    def test_fallback_when_kwave_missing(self):
+        """When k-wave is not installed, calc_delays should fall back
+        to Direct geometric delays."""
+        method = SimulationCorrected()
+        with patch("importlib.util.find_spec", return_value=None), patch.object(
+            SimulationCorrected,
+            "_fallback_delays",
+            return_value=np.array([0.0, 0.0]),
+        ) as mock_fallback:
+            delays = method.calc_delays(
+                arr=None, target=None, params=None, transform=None
+            )
+        mock_fallback.assert_called_once()
+        np.testing.assert_array_equal(delays, [0.0, 0.0])

tests/test_threshold_mri.py

@@ -289,6 +289,30 @@ def test_classify_brain_gmm_failure_fallback() -> None:
         assert set(np.unique(result.to_numpy()[brain_voxels])) == {idx["gray_matter"]}
 
 
+def test_classify_brain_degenerate_constant_intensity() -> None:
+    """When the brain interior has near-constant intensity, the GMM cannot
+    fit meaningful components. All brain voxels should fall back to
+    gray_matter rather than collapsing to CSF (argmax class 0)."""
+    volume = create_synthetic_head_volume(shape=(64, 64, 64), intensity=100.0)
+    seg = ThresholdMRI(
+        classify_brain_tissues=True,
+        air_threshold_quantile=0.0,
+        skull_thickness_mm=7.0,
+    )
+    result = seg._segment(volume)
+    idx = seg._material_indices()
+    brain_labels = {idx["csf"], idx["gray_matter"], idx["white_matter"]}
+    brain_voxels = np.isin(result.to_numpy(), list(brain_labels))
+    if np.any(brain_voxels):
+        unique_brain = set(np.unique(result.to_numpy()[brain_voxels]))
+        assert idx["gray_matter"] in unique_brain, (
+            "Degenerate GMM should fall back to gray_matter"
+        )
+        assert idx["csf"] not in unique_brain, (
+            "Degenerate GMM should not produce all-CSF labels"
+        )
+
+
 def test_gmm_preserves_natural_class_proportions() -> None:
     """EM-GMM should recover class proportions that reflect the actual geometry
     of the concentric spheres, NOT force them to ~33% each (as histogram