basic tests for signalhound without external repo

Author: Kyle A Logue

sigmf/convert/signalhound.py

@@ -203,9 +203,9 @@ def _build_metadata(xml_path: Path) -> Tuple[dict, dict, list, int]:
     # build hardware description with available information
     hw_parts = []
     if device_type:
-        hw_parts.append(f"Recorded with {device_type}")
+        hw_parts.append(f"{device_type}")
     else:
-        hw_parts.append("Recorded with Signal Hound Device")
+        hw_parts.append("Signal Hound Device")
 
     if serial_number:
         hw_parts.append(f"S/N: {serial_number}")

tests/test_convert_signalhound.py

@@ -19,6 +19,107 @@
 from .testdata import get_nonsigmf_path, validate_ncd
 
 
+class TestSignalHoundConverter(unittest.TestCase):
+    """Create a realistic Signal Hound XML/IQ file pair and test conversion methods."""
+
+    def setUp(self) -> None:
+        """Create temp XML/IQ file pair with tone for testing."""
+        self.tmp_dir = tempfile.TemporaryDirectory()
+        self.tmp_path = Path(self.tmp_dir.name)
+        self.iq_path = self.tmp_path / "test.iq"
+        self.xml_path = self.tmp_path / "test.xml"
+
+        # Generate complex IQ test data
+        self.samp_rate = 48000
+        self.center_freq = 915e6
+        duration_s = 0.1
+        num_samples = int(self.samp_rate * duration_s)
+        ttt = np.linspace(0, duration_s, num_samples, endpoint=False)
+        freq = 440  # A4 note
+        self.iq_data = 0.5 * np.exp(2j * np.pi * freq * ttt)  # complex128, normalized to [-0.5, 0.5]
+
+        # Convert complex IQ data to interleaved int16 format (ci16_le - Signal Hound "Complex Short")
+        scale = 2**15  # int16 range is -32768 to 32767
+        ci_real = (self.iq_data.real * scale).astype(np.int16)
+        ci_imag = (self.iq_data.imag * scale).astype(np.int16)
+        iq_interleaved = np.empty((len(self.iq_data) * 2,), dtype=np.int16)
+        iq_interleaved[0::2] = ci_real
+        iq_interleaved[1::2] = ci_imag
+
+        # Write IQ file as raw interleaved int16
+        with open(self.iq_path, "wb") as iq_file:
+            iq_file.write(iq_interleaved.tobytes())
+
+        # Write minimal XML metadata file
+        with open(self.xml_path, "w") as xml_file:
+            xml_file.write(
+                f'<?xml version="1.0" encoding="UTF-8"?>\n'
+                f'<SignalHoundIQFile Version="1.0">\n'
+                f"    <CenterFrequency>{self.center_freq}</CenterFrequency>\n"
+                f"    <SampleRate>{self.samp_rate}</SampleRate>\n"
+                f"    <DataType>Complex Short</DataType>\n"
+                f"    <IQFileName>{self.iq_path.name}</IQFileName>\n"
+                f"</SignalHoundIQFile>\n"
+            )
+
+    def tearDown(self) -> None:
+        """Clean up temporary directory."""
+        self.tmp_dir.cleanup()
+
+    def _verify(self, meta: sigmf.SigMFFile) -> None:
+        """Verify metadata fields and data integrity."""
+        self.assertIsInstance(meta, sigmf.SigMFFile)
+        self.assertEqual(meta.get_global_field("core:datatype"), "ci16_le")
+        self.assertEqual(meta.get_global_field("core:sample_rate"), self.samp_rate)
+        # center frequency is in capture metadata
+        self.assertEqual(meta.get_captures()[0]["core:frequency"], self.center_freq)
+        # verify data
+        data = meta.read_samples()
+        self.assertGreater(len(data), 0, "Should read some samples")
+        # allow numerical differences due to int16 quantization
+        self.assertTrue(np.allclose(self.iq_data, data, atol=1e-4))
+
+    def test_signalhound_to_sigmf_pair(self):
+        """Test standard Signal Hound to SigMF conversion with file pairs."""
+        sigmf_path = self.tmp_path / "converted"
+        meta = signalhound_to_sigmf(signalhound_path=self.xml_path, out_path=sigmf_path)
+        filenames = sigmf.sigmffile.get_sigmf_filenames(sigmf_path)
+        self.assertTrue(filenames["data_fn"].exists(), "dataset path missing")
+        self.assertTrue(filenames["meta_fn"].exists(), "metadata path missing")
+        self._verify(meta)
+
+        # test overwrite protection
+        with self.assertRaises(sigmf.error.SigMFFileError) as context:
+            signalhound_to_sigmf(signalhound_path=self.xml_path, out_path=sigmf_path, overwrite=False)
+        self.assertIn("already exists", str(context.exception))
+
+        # test overwrite works
+        meta2 = signalhound_to_sigmf(signalhound_path=self.xml_path, out_path=sigmf_path, overwrite=True)
+        self.assertIsInstance(meta2, sigmf.SigMFFile)
+
+    def test_signalhound_to_sigmf_archive(self):
+        """Test Signal Hound to SigMF conversion with archive output."""
+        sigmf_path = self.tmp_path / "converted_archive"
+        meta = signalhound_to_sigmf(signalhound_path=self.xml_path, out_path=sigmf_path, create_archive=True)
+        filenames = sigmf.sigmffile.get_sigmf_filenames(sigmf_path)
+        self.assertTrue(filenames["archive_fn"].exists(), "archive path missing")
+        self._verify(meta)
+
+        # test overwrite protection
+        with self.assertRaises(sigmf.error.SigMFFileError) as context:
+            signalhound_to_sigmf(
+                signalhound_path=self.xml_path, out_path=sigmf_path, create_archive=True, overwrite=False
+            )
+        self.assertIn("already exists", str(context.exception))
+
+    def test_signalhound_to_sigmf_ncd(self):
+        """Test Signal Hound to SigMF conversion as Non-Conforming Dataset."""
+        meta = signalhound_to_sigmf(signalhound_path=self.xml_path, create_ncd=True)
+        target_path = self.iq_path
+        validate_ncd(self, meta, target_path)
+        self._verify(meta)
+
+
 class TestSignalHoundWithNonSigMFRepo(unittest.TestCase):
     """Test Signal Hound converter with real example files if available."""
 

tests/test_convert_wav.py

@@ -46,18 +46,23 @@ def tearDown(self) -> None:
         """clean up temporary directory"""
         self.tmp_dir.cleanup()
 
+    def _verify(self, meta: sigmf.SigMFFile) -> None:
+        """Verify metadata fields and data integrity."""
+        self.assertIsInstance(meta, sigmf.SigMFFile)
+        # verify data
+        data = meta.read_samples()
+        self.assertGreater(len(data), 0, "Should read some samples")
+        # allow numerical differences due to PCM quantization
+        self.assertTrue(np.allclose(self.audio_data, data, atol=1e-4))
+
     def test_wav_to_sigmf_pair(self) -> None:
         """test standard wav to sigmf conversion with file pairs"""
         sigmf_path = self.tmp_path / "bar"
         meta = wav_to_sigmf(wav_path=self.wav_path, out_path=sigmf_path)
         filenames = sigmf.sigmffile.get_sigmf_filenames(sigmf_path)
         self.assertTrue(filenames["data_fn"].exists(), "dataset path missing")
         self.assertTrue(filenames["meta_fn"].exists(), "metadata path missing")
-        # verify data
-        data = meta.read_samples()
-        self.assertGreater(len(data), 0, "Should read some samples")
-        # allow numerical differences due to PCM quantization
-        self.assertTrue(np.allclose(self.audio_data, data, atol=1e-4))
+        self._verify(meta)
 
         # test overwrite protection
         with self.assertRaises(sigmf.error.SigMFFileError) as context:
@@ -74,11 +79,7 @@ def test_wav_to_sigmf_archive(self) -> None:
         meta = wav_to_sigmf(wav_path=self.wav_path, out_path=sigmf_path, create_archive=True)
         filenames = sigmf.sigmffile.get_sigmf_filenames(sigmf_path)
         self.assertTrue(filenames["archive_fn"].exists(), "archive path missing")
-        # verify data
-        data = meta.read_samples()
-        self.assertGreater(len(data), 0, "Should read some samples")
-        # allow numerical differences due to PCM quantization
-        self.assertTrue(np.allclose(self.audio_data, data, atol=1e-4))
+        self._verify(meta)
 
         # test overwrite protection
         with self.assertRaises(sigmf.error.SigMFFileError) as context:
@@ -93,12 +94,7 @@ def test_wav_to_sigmf_ncd(self) -> None:
         """test wav to sigmf conversion as Non-Conforming Dataset"""
         meta = wav_to_sigmf(wav_path=self.wav_path, create_ncd=True)
         validate_ncd(self, meta, self.wav_path)
-
-        # verify data
-        data = meta.read_samples()
-        # allow numerical differences due to PCM quantization
-        self.assertGreater(len(data), 0, "Should read some samples")
-        self.assertTrue(np.allclose(self.audio_data, data, atol=1e-4))
+        self._verify(meta)
 
         # test overwrite protection when creating NCD with output path
         sigmf_path = self.tmp_path / "ncd_test"