sim-logic 0.1.0

A code-first application and logic layer for Sim;Engine
Documentation
use std::{cell::Cell, iter, sync::atomic::AtomicU64};

use super::*;

fn source<I: Iterator<Item = f32>>(samples: I, status: &AudioOutputStatus) -> MonoSource<I> {
    MonoSource {
        source: samples,
        sample_rate: NonZeroU32::new(48_000).unwrap(),
        status: status.clone(),
        ended: false,
    }
}

#[test]
fn buffer_request_bounds_and_fallback_are_explicit() {
    let default = AudioOutputConfig::default();
    assert_eq!(default.buffer_frames(), 512);
    assert!(!default.device_buffer_fallback());
    for frames in [1, 256, 512, MAX_BUFFER_FRAMES] {
        let config = AudioOutputConfig::new(frames).unwrap();
        assert_eq!(config.buffer_frames(), frames);
        assert!(!config.device_buffer_fallback());
        let enabled = config.with_device_buffer_fallback(true);
        assert!(enabled.device_buffer_fallback());
        assert_eq!(enabled.buffer_frames(), frames);
        assert_eq!(enabled.with_device_buffer_fallback(false), config);
    }
    for requested in [0, MAX_BUFFER_FRAMES + 1, u32::MAX] {
        assert!(matches!(AudioOutputConfig::new(requested),
            Err(AudioOutputError::InvalidBufferFrames { requested: actual, maximum })
            if actual == requested && maximum == MAX_BUFFER_FRAMES));
    }
}

#[test]
fn successful_fixed_open_never_tries_the_optional_fallback() {
    for enabled in [false, true] {
        let mut requests = Vec::new();
        let result = open_with_policy(
            AudioOutputConfig::default().with_device_buffer_fallback(enabled),
            |buffer| {
                requests.push(buffer);
                Ok(7)
            },
        )
        .unwrap();
        assert_eq!(result, (7, false));
        assert_eq!(requests, [BufferSize::Fixed(512)]);
    }
}

#[test]
fn disabled_fallback_returns_the_first_error_without_another_attempt() {
    let mut requests = Vec::new();
    let result = open_with_policy::<()>(AudioOutputConfig::default(), |buffer| {
        requests.push(buffer);
        Err(DeviceSinkError::NoDevice)
    });
    assert!(matches!(
        result,
        Err(AudioOutputError::Open {
            requested: DeviceSinkError::NoDevice,
            fallback: None,
        })
    ));
    assert_eq!(requests, [BufferSize::Fixed(512)]);
}

#[test]
fn enabled_fallback_reports_success_or_retains_both_errors() {
    for succeeds in [false, true] {
        let mut requests = Vec::new();
        let result = open_with_policy(
            AudioOutputConfig::default().with_device_buffer_fallback(true),
            |buffer| {
                requests.push(buffer);
                match buffer {
                    BufferSize::Fixed(_) => Err(DeviceSinkError::NoDevice),
                    BufferSize::Default if succeeds => Ok(9),
                    BufferSize::Default => Err(DeviceSinkError::UnsupportedSampleFormat),
                }
            },
        );
        assert_eq!(requests, [BufferSize::Fixed(512), BufferSize::Default]);
        if succeeds {
            assert_eq!(result.unwrap(), (9, true));
        } else {
            let error = result.unwrap_err();
            assert!(error.source().is_some());
            assert!(error.to_string().contains("retry also failed"));
            assert!(matches!(
                error,
                AudioOutputError::Open {
                    requested: DeviceSinkError::NoDevice,
                    fallback: Some(DeviceSinkError::UnsupportedSampleFormat),
                }
            ));
        }
    }
}

#[test]
fn nonfinite_pcm_is_silenced_and_out_of_range_pcm_is_clamped() {
    let status = AudioOutputStatus::new();
    let mut samples = source(
        [
            f32::NAN,
            f32::INFINITY,
            f32::NEG_INFINITY,
            2.0,
            -3.0,
            1.0,
            -1.0,
            -0.0,
            0.25,
        ]
        .into_iter(),
        &status,
    );
    assert_eq!(samples.channels(), NonZeroU16::MIN);
    assert_eq!(samples.sample_rate().get(), 48_000);
    assert_eq!(samples.current_span_len(), None);
    assert_eq!(samples.total_duration(), None);
    let values: Vec<_> = samples.by_ref().collect();
    assert_eq!(values, [0.0, 0.0, 0.0, 1.0, -1.0, 1.0, -1.0, -0.0, 0.25]);
    assert_eq!(
        values[7].to_bits(),
        rodio::Sample::from_sample(-0.0_f32).to_bits()
    );
    assert_eq!(status.generated_sample_count(), 9);
    assert_eq!(status.invalid_sample_count(), 5);
    assert!(status.is_finished());
    assert!(!status.is_closed());
    assert!(!status.is_faulted());
    assert_eq!(samples.current_span_len(), Some(0));
    assert_eq!(samples.next(), None);
    assert_eq!(status.generated_sample_count(), 9);
}

#[test]
fn first_none_fuses_even_a_source_that_would_resume() {
    let status = AudioOutputStatus::new();
    let calls = Cell::new(0);
    let input = iter::from_fn(|| {
        calls.set(calls.get() + 1);
        if calls.get() == 2 { None } else { Some(0.5) }
    });
    let mut samples = source(input, &status);
    assert_eq!(samples.next(), Some(0.5));
    assert_eq!(samples.next(), None);
    for _ in 0..10 {
        assert_eq!(samples.next(), None);
    }
    assert_eq!(calls.get(), 2);
    assert_eq!(status.generated_sample_count(), 1);
    assert!(status.is_finished());
}

#[test]
fn stopped_silence_remains_live_and_can_resume_without_a_second_source() {
    let status = AudioOutputStatus::new();
    let playing = Cell::new(false);
    let input = iter::from_fn(|| Some(if playing.get() { 0.25 } else { 0.0 }));
    let mut samples = source(input, &status);
    for _ in 0..100 {
        assert_eq!(samples.next(), Some(0.0));
    }
    assert!(!status.is_finished());
    playing.set(true);
    assert_eq!(samples.next(), Some(0.25));
    playing.set(false);
    assert_eq!(samples.next(), Some(0.0));
    assert_eq!(status.generated_sample_count(), 102);
    assert_eq!(status.invalid_sample_count(), 0);
}

#[test]
fn mono_attachment_does_not_preconsume_or_count_again_for_output_channels() {
    for channels in [1, 2, 4] {
        let status = AudioOutputStatus::new();
        let samples = source([0.25, 0.5, 0.75].into_iter(), &status);
        let (mixer, mut output) =
            rodio::mixer::mixer(NonZeroU16::new(channels).unwrap(), samples.sample_rate());
        mixer.add(samples);
        assert_eq!(status.generated_sample_count(), 0);
        for (frame, value) in [0.25, 0.5, 0.75].into_iter().enumerate() {
            for channel in 0..channels {
                assert_eq!(output.next(), Some(if channel < 2 { value } else { 0.0 }));
                assert_eq!(status.generated_sample_count(), frame as u64 + 1);
            }
        }
        assert_eq!(output.next(), None);
        assert!(status.is_finished());
        assert_eq!(status.generated_sample_count(), 3);
    }
}

#[test]
fn status_outlives_owner_and_faults_do_not_imply_source_exhaustion() {
    let status = AudioOutputStatus::new();
    let observer = status.clone();
    let lifetime = OutputLifetime { status };
    observer.record_stream_error();
    observer.record_stream_error();
    assert!(observer.is_faulted());
    assert_eq!(observer.stream_error_count(), 2);
    assert!(!observer.is_closed());
    assert!(!observer.is_finished());
    drop(lifetime);
    assert!(observer.is_closed());
    assert!(!observer.is_finished());
    assert_eq!(observer.stream_error_count(), 2);
}

#[test]
fn diagnostics_can_be_observed_across_threads_and_counters_saturate() {
    let status = AudioOutputStatus::new();
    let writer = status.clone();
    std::thread::spawn(move || {
        let mut samples = source(iter::repeat_n(0.25, 100), &writer);
        assert_eq!(samples.by_ref().count(), 100);
        writer.record_stream_error();
    })
    .join()
    .unwrap();
    assert_eq!(status.generated_sample_count(), 100);
    assert_eq!(status.stream_error_count(), 1);
    assert!(status.is_finished());
    let counter = AtomicU64::new(u64::MAX - 1);
    increment(&counter);
    increment(&counter);
    assert_eq!(counter.load(Ordering::Relaxed), u64::MAX);
}