[add] tests to increase the code coverage.

Author: vmarcella

crates/lambda-rs-platform/src/audio/cpal/device.rs

@@ -991,6 +991,160 @@ mod tests {
 
   use super::*;
 
+  /// Normalized sample clamping MUST clamp to the nominal output range.
+  #[test]
+  fn clamp_normalized_sample_clamps_to_nominal_range() {
+    assert_eq!(clamp_normalized_sample(2.0), 1.0);
+    assert_eq!(clamp_normalized_sample(-2.0), -1.0);
+    assert_eq!(clamp_normalized_sample(0.25), 0.25);
+    return;
+  }
+
+  /// Sample format priority MUST prefer `f32`, then `i16`, then `u16`.
+  #[test]
+  fn sample_format_priority_orders_supported_formats() {
+    assert!(
+      sample_format_priority(cpal_backend::SampleFormat::F32)
+        > sample_format_priority(cpal_backend::SampleFormat::I16)
+    );
+    assert!(
+      sample_format_priority(cpal_backend::SampleFormat::I16)
+        > sample_format_priority(cpal_backend::SampleFormat::U16)
+    );
+    assert_eq!(sample_format_priority(cpal_backend::SampleFormat::I8), 0);
+    return;
+  }
+
+  /// Platform audio error display MUST cover each error variant.
+  #[test]
+  fn platform_audio_error_display_covers_each_variant() {
+    let cases = [
+      AudioError::InvalidSampleRate { requested: 0 }.to_string(),
+      AudioError::InvalidChannels { requested: 0 }.to_string(),
+      AudioError::HostUnavailable {
+        details: "missing".to_string(),
+      }
+      .to_string(),
+      AudioError::NoDefaultDevice.to_string(),
+      AudioError::DeviceNameUnavailable {
+        details: "name".to_string(),
+      }
+      .to_string(),
+      AudioError::DeviceEnumerationFailed {
+        details: "enum".to_string(),
+      }
+      .to_string(),
+      AudioError::SupportedConfigsUnavailable {
+        details: "configs".to_string(),
+      }
+      .to_string(),
+      AudioError::UnsupportedConfig {
+        requested_sample_rate: Some(44_100),
+        requested_channels: Some(2),
+      }
+      .to_string(),
+      AudioError::UnsupportedSampleFormat {
+        details: "fmt".to_string(),
+      }
+      .to_string(),
+      AudioError::Platform {
+        details: "backend".to_string(),
+      }
+      .to_string(),
+      AudioError::StreamBuildFailed {
+        details: "build".to_string(),
+      }
+      .to_string(),
+      AudioError::StreamPlayFailed {
+        details: "play".to_string(),
+      }
+      .to_string(),
+    ];
+
+    assert!(cases.iter().all(|value| !value.trim().is_empty()));
+    return;
+  }
+
+  /// Output buffer helpers MUST report length and format.
+  #[test]
+  fn output_buffer_reports_length_and_format() {
+    let mut samples_f32 = [0.0f32, 0.0];
+    let buffer = AudioOutputBuffer::F32(&mut samples_f32);
+    assert_eq!(buffer.len(), 2);
+    assert_eq!(buffer.sample_format(), AudioSampleFormat::F32);
+
+    let mut samples_i16 = [0i16, 0];
+    let buffer = AudioOutputBuffer::I16(&mut samples_i16);
+    assert_eq!(buffer.len(), 2);
+    assert_eq!(buffer.sample_format(), AudioSampleFormat::I16);
+
+    let mut samples_u16 = [0u16, 0];
+    let buffer = AudioOutputBuffer::U16(&mut samples_u16);
+    assert_eq!(buffer.len(), 2);
+    assert_eq!(buffer.sample_format(), AudioSampleFormat::U16);
+    return;
+  }
+
+  /// Writer construction MUST handle invalid channel counts without panicking.
+  #[test]
+  fn writer_new_handles_zero_channels() {
+    let mut samples_f32 = [0.0f32, 0.0];
+    let writer = InterleavedAudioOutputWriter::new(
+      0,
+      AudioOutputBuffer::F32(&mut samples_f32),
+    );
+    assert_eq!(writer.frames(), 0);
+    assert_eq!(writer.channels(), 0);
+    assert_eq!(writer.sample_format(), AudioSampleFormat::F32);
+    return;
+  }
+
+  /// Config selection MUST reject devices that only expose unsupported formats.
+  #[test]
+  fn select_output_stream_config_rejects_all_unsupported_formats() {
+    let supported_configs = [cpal_backend::SupportedStreamConfigRange::new(
+      2,
+      44_100,
+      48_000,
+      SupportedBufferSize::Unknown,
+      cpal_backend::SampleFormat::I8,
+    )];
+
+    let result = select_output_stream_config(&supported_configs, None, None);
+    assert!(matches!(
+      result,
+      Err(AudioError::UnsupportedSampleFormat { .. })
+    ));
+    return;
+  }
+
+  /// Config selection MUST pick the sample rate closest to 48_000 when
+  /// priorities tie.
+  #[test]
+  fn select_output_stream_config_prefers_closest_sample_rate_when_tied() {
+    let supported_configs = [
+      cpal_backend::SupportedStreamConfigRange::new(
+        2,
+        44_100,
+        44_100,
+        SupportedBufferSize::Unknown,
+        cpal_backend::SampleFormat::F32,
+      ),
+      cpal_backend::SupportedStreamConfigRange::new(
+        2,
+        48_000,
+        48_000,
+        SupportedBufferSize::Unknown,
+        cpal_backend::SampleFormat::F32,
+      ),
+    ];
+
+    let selected =
+      select_output_stream_config(&supported_configs, None, None).unwrap();
+    assert_eq!(selected.sample_rate(), 48_000);
+    return;
+  }
+
   /// Builder MUST reject invalid sample rates.
   #[test]
   fn build_rejects_zero_sample_rate() {

crates/lambda-rs-platform/src/audio/symphonia/mod.rs

@@ -569,8 +569,128 @@ pub fn decode_ogg_vorbis_bytes(
 
 #[cfg(test)]
 mod tests {
+  use std::io;
+
+  use symphonia::core::audio::{
+    AsAudioBufferRef,
+    AudioBuffer,
+    Channels,
+    SignalSpec,
+  };
+
   use super::*;
 
+  /// Probe-time error mapping MUST produce stable vendor-free variants.
+  #[test]
+  fn probe_error_mapping_produces_vendor_free_errors() {
+    let unsupported = map_probe_error("WAV", Error::Unsupported("container"));
+    assert!(matches!(
+      unsupported,
+      AudioDecodeError::UnsupportedFormat { .. }
+    ));
+
+    let io_error = map_probe_error(
+      "WAV",
+      Error::IoError(io::Error::new(io::ErrorKind::UnexpectedEof, "eof")),
+    );
+    assert!(matches!(io_error, AudioDecodeError::InvalidData { .. }));
+
+    let other = map_probe_error("WAV", Error::LimitError("limit"));
+    assert!(matches!(other, AudioDecodeError::DecodeFailed { .. }));
+    return;
+  }
+
+  /// Decode-time error mapping MUST produce stable vendor-free variants.
+  #[test]
+  fn decode_error_mapping_produces_vendor_free_errors() {
+    let unsupported =
+      map_read_or_decode_error("OGG Vorbis", Error::Unsupported("codec"));
+    assert!(matches!(
+      unsupported,
+      AudioDecodeError::UnsupportedFormat { .. }
+    ));
+
+    let decode_error =
+      map_read_or_decode_error("OGG Vorbis", Error::DecodeError("bad"));
+    assert!(matches!(decode_error, AudioDecodeError::InvalidData { .. }));
+
+    let io_error = map_read_or_decode_error(
+      "OGG Vorbis",
+      Error::IoError(io::Error::new(io::ErrorKind::UnexpectedEof, "eof")),
+    );
+    assert!(matches!(io_error, AudioDecodeError::InvalidData { .. }));
+
+    let other = map_read_or_decode_error("OGG Vorbis", Error::LimitError("x"));
+    assert!(matches!(other, AudioDecodeError::DecodeFailed { .. }));
+    return;
+  }
+
+  /// Sample reservation MUST be a no-op when metadata is unavailable.
+  #[test]
+  fn reserve_samples_is_noop_without_metadata() {
+    let mut samples = Vec::new();
+    try_reserve_samples(&mut samples, "WAV", None, None)
+      .expect("reserve should succeed");
+    return;
+  }
+
+  /// Sample reservation MUST skip sizes that cannot fit on 32-bit targets.
+  #[cfg(target_pointer_width = "32")]
+  #[test]
+  fn reserve_samples_skips_overflowing_sizes_on_32_bit_targets() {
+    let mut samples = Vec::new();
+    try_reserve_samples(&mut samples, "WAV", Some(u64::MAX), Some(u16::MAX))
+      .expect("reserve should skip overflow");
+    return;
+  }
+
+  /// Sample reservation MUST succeed for reasonable metadata on 64-bit targets.
+  #[cfg(target_pointer_width = "64")]
+  #[test]
+  fn reserve_samples_reserves_for_reasonable_metadata_on_64_bit_targets() {
+    let mut samples = Vec::new();
+    try_reserve_samples(&mut samples, "WAV", Some(4), Some(2))
+      .expect("reserve should succeed");
+    return;
+  }
+
+  /// WAV decoded sample format names MUST be stable.
+  #[test]
+  fn wav_decoded_sample_format_name_is_stable() {
+    let spec = SignalSpec::new(44_100, Channels::FRONT_LEFT);
+    let buffer_u8 = AudioBuffer::<u8>::new(1, spec);
+    let buffer = buffer_u8.as_audio_buffer_ref();
+    assert_eq!(wav_decoded_sample_format_name(&buffer), "U8");
+
+    let buffer_i16 = AudioBuffer::<i16>::new(1, spec);
+    let buffer = buffer_i16.as_audio_buffer_ref();
+    assert_eq!(wav_decoded_sample_format_name(&buffer), "S16");
+
+    let buffer_f32 = AudioBuffer::<f32>::new(1, spec);
+    let buffer = buffer_f32.as_audio_buffer_ref();
+    assert_eq!(wav_decoded_sample_format_name(&buffer), "F32");
+    return;
+  }
+
+  /// WAV decoded sample format validation MUST reject unsupported formats.
+  #[test]
+  fn wav_decoded_sample_format_validation_rejects_unsupported_formats() {
+    let spec = SignalSpec::new(44_100, Channels::FRONT_LEFT);
+    let unsupported_u8 = AudioBuffer::<u8>::new(1, spec);
+    let unsupported = unsupported_u8.as_audio_buffer_ref();
+    let result = validate_wav_decoded_sample_format(&unsupported);
+    assert!(matches!(
+      result,
+      Err(AudioDecodeError::UnsupportedFormat { .. })
+    ));
+
+    let supported_i16 = AudioBuffer::<i16>::new(1, spec);
+    let supported = supported_i16.as_audio_buffer_ref();
+    validate_wav_decoded_sample_format(&supported)
+      .expect("format should be supported");
+    return;
+  }
+
   /// Fixture: 44100 Hz, mono, 16-bit integer PCM.
   #[cfg(feature = "audio-decode-wav")]
   const TONE_S16_MONO_44100_WAV: &[u8] = include_bytes!(concat!(

crates/lambda-rs/src/audio/buffer.rs

@@ -242,6 +242,69 @@ mod tests {
     return;
   }
 
+  /// Frames MUST return 0 when channel metadata is invalid.
+  #[test]
+  fn frames_returns_zero_when_channels_is_zero() {
+    let buffer = SoundBuffer {
+      samples: vec![0.0, 0.0],
+      sample_rate: 48_000,
+      channels: 0,
+    };
+
+    assert_eq!(buffer.frames(), 0);
+    assert_eq!(buffer.duration_seconds(), 0.0);
+    return;
+  }
+
+  /// Decoded audio conversion MUST reject invalid metadata.
+  #[test]
+  fn from_decoded_rejects_invalid_metadata() {
+    let result = SoundBuffer::from_decoded(
+      lambda_platform::audio::symphonia::DecodedAudio {
+        samples: vec![0.0],
+        sample_rate: 0,
+        channels: 1,
+      },
+    );
+    assert!(matches!(result, Err(AudioError::InvalidData { .. })));
+
+    let result = SoundBuffer::from_decoded(
+      lambda_platform::audio::symphonia::DecodedAudio {
+        samples: vec![0.0],
+        sample_rate: 44_100,
+        channels: 0,
+      },
+    );
+    assert!(matches!(result, Err(AudioError::InvalidData { .. })));
+    return;
+  }
+
+  /// Decode error mapping MUST preserve stable variants.
+  #[test]
+  fn map_decode_error_preserves_variants() {
+    let unsupported = map_decode_error(
+      lambda_platform::audio::symphonia::AudioDecodeError::UnsupportedFormat {
+        details: "wav".to_string(),
+      },
+    );
+    assert!(matches!(unsupported, AudioError::UnsupportedFormat { .. }));
+
+    let invalid = map_decode_error(
+      lambda_platform::audio::symphonia::AudioDecodeError::InvalidData {
+        details: "bad".to_string(),
+      },
+    );
+    assert!(matches!(invalid, AudioError::InvalidData { .. }));
+
+    let failed = map_decode_error(
+      lambda_platform::audio::symphonia::AudioDecodeError::DecodeFailed {
+        details: "boom".to_string(),
+      },
+    );
+    assert!(matches!(failed, AudioError::DecodeFailed { .. }));
+    return;
+  }
+
   /// WAV decode from bytes MUST succeed for the bundled fixture.
   #[cfg(feature = "audio-sound-buffer-wav")]
   #[test]