check

tests/test_processing.py

@@ -10,6 +10,7 @@ from rfg_adc_plotter.gui.pyqtgraph_backend import (
     apply_working_range,
     apply_working_range_to_aux_curves,
     compute_background_subtracted_bscan_levels,
+    resolve_visible_fft_curves,
     resolve_visible_aux_curves,
 )
 from rfg_adc_plotter.processing.calibration import (
@@ -28,6 +29,7 @@ from rfg_adc_plotter.processing.fft import (
     build_positive_only_centered_ifft_spectrum,
     build_symmetric_ifft_spectrum,
     compute_distance_axis,
+    compute_fft_complex_row,
     compute_fft_mag_row,
     compute_fft_row,
     fft_mag_to_db,
@@ -287,14 +289,51 @@ class ProcessingTests(unittest.TestCase):
     def test_compute_fft_helpers_accept_complex_input(self):
         sweep = np.exp(1j * np.linspace(0.0, 2.0 * np.pi, 128)).astype(np.complex64)
         freqs = np.linspace(3.3, 14.3, 128, dtype=np.float64)
+        complex_row = compute_fft_complex_row(sweep, freqs, 513, mode="positive_only")
         mag = compute_fft_mag_row(sweep, freqs, 513, mode="positive_only")
         row = compute_fft_row(sweep, freqs, 513, mode="positive_only")
 
+        self.assertEqual(complex_row.shape, (513,))
+        self.assertTrue(np.iscomplexobj(complex_row))
         self.assertEqual(mag.shape, (513,))
         self.assertEqual(row.shape, (513,))
+        self.assertTrue(np.allclose(mag, np.abs(complex_row), equal_nan=True))
         self.assertTrue(np.any(np.isfinite(mag)))
         self.assertTrue(np.any(np.isfinite(row)))
 
+    def test_resolve_visible_fft_curves_handles_complex_mode(self):
+        complex_row = np.asarray([1.0 + 2.0j, -3.0 + 4.0j], dtype=np.complex64)
+        mag = np.abs(complex_row).astype(np.float32)
+
+        abs_curve, real_curve, imag_curve = resolve_visible_fft_curves(
+            complex_row,
+            mag,
+            complex_mode=True,
+            show_abs=True,
+            show_real=False,
+            show_imag=True,
+        )
+
+        self.assertTrue(np.allclose(abs_curve, mag))
+        self.assertIsNone(real_curve)
+        self.assertTrue(np.allclose(imag_curve, np.asarray([2.0, 4.0], dtype=np.float32)))
+
+    def test_resolve_visible_fft_curves_preserves_legacy_abs_mode(self):
+        mag = np.asarray([1.0, 2.0, 3.0], dtype=np.float32)
+
+        abs_curve, real_curve, imag_curve = resolve_visible_fft_curves(
+            None,
+            mag,
+            complex_mode=False,
+            show_abs=True,
+            show_real=True,
+            show_imag=True,
+        )
+
+        self.assertTrue(np.allclose(abs_curve, mag))
+        self.assertIsNone(real_curve)
+        self.assertIsNone(imag_curve)
+
     def test_symmetric_distance_axis_uses_windowed_frequency_bounds(self):
         freqs = np.linspace(4.0, 10.0, 128, dtype=np.float64)
         axis = compute_distance_axis(freqs, 513, mode="symmetric")

tests/test_ring_buffer.py

@@ -84,6 +84,7 @@ class RingBufferTests(unittest.TestCase):
 
         expected = compute_fft_mag_row(complex_input, freqs, ring.fft_bins, mode="direct")
         self.assertTrue(np.allclose(ring.get_last_fft_linear(), expected))
+        self.assertFalse(np.iscomplexobj(ring.get_display_fft_linear()))
         self.assertTrue(np.allclose(ring.get_display_raw()[: display_sweep.size, -1], display_sweep))
 
     def test_ring_buffer_reset_clears_cached_history(self):

tests/test_sweep_parser_core.py

@@ -134,6 +134,7 @@ class SweepParserCoreTests(unittest.TestCase):
         self.assertEqual(events[0].ch, 2)
         self.assertIsInstance(events[1], PointEvent)
         self.assertEqual(events[1].ch, 2)
+        self.assertAlmostEqual(events[1].y, math.hypot(100.0, 90.0), places=6)
         self.assertEqual(events[1].aux, (100.0, 90.0))
 
     def test_parser_test_stream_parser_recovers_point_after_single_separator(self):
@@ -155,7 +156,8 @@ class SweepParserCoreTests(unittest.TestCase):
         self.assertIsInstance(events[1], PointEvent)
         self.assertEqual(events[1].ch, 4)
         self.assertEqual(events[1].x, 1)
-        self.assertTrue(math.isfinite(events[1].y))
+        self.assertAlmostEqual(events[1].y, math.hypot(100.0, 90.0), places=6)
+        self.assertEqual(events[1].aux, (100.0, 90.0))
 
     def test_sweep_assembler_builds_aux_curves_without_inversion(self):
         assembler = SweepAssembler(fancy=False, apply_inversion=False)