use super::*;
#[test]
#[ignore = "plays real UI cues on the default output; record its monitor to check audibility"]
fn default_output_monitor_probe() {
let audio = UiAudio::with_factory(true, 100, DefaultOutput::open);
let deadline = Instant::now() + Duration::from_secs(5);
while !audio.shared.ready.load(Ordering::Relaxed) {
assert!(
Instant::now() < deadline,
"default output did not become ready"
);
std::thread::sleep(Duration::from_millis(5));
}
// Let the device consume the initially empty mixer before the first click,
// and leave idle gaps to catch detachment after a voice finishes as well.
std::thread::sleep(Duration::from_millis(300));
for cue in [UiCue::Click, UiCue::Confirm, UiCue::Checkbox] {
audio.play(cue);
std::thread::sleep(Duration::from_millis(400));
}
}
#[test]
fn clamped_mix_survives_idle_before_and_between_players() {
use std::num::NonZero;
let channels = NonZero::new(2).unwrap();
let rate = NonZero::new(48000).unwrap();
let (device, mut rendered) = rodio::mixer::mixer(channels, rate);
let (mixer, source) = clamped_mixer(channels, rate);
device.add(source);
for _ in 0..2 {
// A real device consumes the source before the first user interaction,
// and removes it permanently if it ever returns None between cues.
for _ in 0..4800 {
assert_eq!(rendered.next(), Some(0.0));
}
let player = rodio::Player::connect_new(&mixer);
player.set_volume(0.5);
player.append(SamplesBuffer::new(channels, rate, vec![0.5; 960]));
let samples: Vec<_> = rendered.by_ref().take(48000).collect();
assert_eq!(samples.len(), 48000);
assert!(
samples.contains(&0.25),
"late player must reach the device mix"
);
assert!(player.empty());
}
}
use std::{cell::Cell, rc::Rc, sync::atomic::AtomicUsize};
struct FakeVoice {
stopped: Rc<Cell<usize>>,
gain: Rc<Cell<f32>>,
}
impl Voice for FakeVoice {
fn done(&self) -> bool {
false
}
fn stop(&self) {
self.stopped.set(self.stopped.get() + 1);
}
fn volume(&self, gain: f32) {
self.gain.set(gain);
}
}
struct FakeOutput {
stopped: Rc<Cell<usize>>,
gain: Rc<Cell<f32>>,
played: Rc<Cell<usize>>,
}
impl Output for FakeOutput {
fn play(&self, _: SamplesBuffer, gain: f32) -> Box<dyn Voice> {
self.played.set(self.played.get() + 1);
self.gain.set(gain);
Box::new(FakeVoice {
stopped: self.stopped.clone(),
gain: self.gain.clone(),
})
}
}
fn output() -> FakeOutput {
FakeOutput {
stopped: Rc::new(Cell::new(0)),
gain: Rc::new(Cell::new(0.0)),
played: Rc::new(Cell::new(0)),
}
}
#[test]
fn mappings_embedded_decode_and_corrupt_missing_assets_are_device_free() {
assert_eq!(mapping(UiCue::None), None);
let clips = preload(&EMBEDDED);
assert_eq!(clips.len(), 10);
for (i, cue) in CUES.into_iter().enumerate() {
assert_eq!(
mapping(cue),
Some((i, if cue == UiCue::Red { 0.5 } else { 1.0 }))
);
let clip = clips[i].clone().expect(FILES[i]);
assert!(clip.channels().get() > 0 && clip.sample_rate().get() > 0);
assert!(clip.count() > 0);
}
assert!(decode(b"").is_none());
assert!(decode(b"OggS corrupt").is_none());
let mut payloads = EMBEDDED;
payloads[2] = b"corrupt";
let mut clips = preload(&payloads);
assert!(clips[2].is_none());
clips[3] = None;
let out = output();
let mut voices = Voices::default();
for cue in [UiCue::Red, UiCue::Tool] {
voices.play(cue, Instant::now(), &clips, &out, 0.5);
}
assert_eq!(out.played.get(), 0);
voices.play(UiCue::Click, Instant::now(), &clips, &out, 0.5);
assert_eq!(out.played.get(), 1);
}
#[test]
fn overlapping_voices_are_bounded_oldest_replaced_gain_mute_and_error_throttled() {
let clips = preload(&EMBEDDED);
let out = output();
let mut voices = Voices::default();
let now = Instant::now();
for _ in 0..7 {
voices.play(UiCue::Click, now, &clips, &out, 0.5);
}
assert_eq!(voices.active.len(), 3);
assert_eq!(out.stopped.get(), 4);
for cue in CUES.into_iter().skip(1) {
voices.play(cue, now, &clips, &out, 0.5);
}
assert_eq!(voices.active.len(), 8);
let played = out.played.get();
voices.play(
UiCue::Cannot,
now + Duration::from_millis(249),
&clips,
&out,
0.5,
);
assert_eq!(out.played.get(), played);
voices.play(
UiCue::Cannot,
now + Duration::from_millis(250),
&clips,
&out,
0.5,
);
assert_eq!(out.played.get(), played + 1);
voices.stop();
assert!(voices.active.is_empty());
voices.play(UiCue::Red, now, &clips, &out, 0.5);
assert_eq!(out.gain.get(), 0.25);
voices.volume(1.0);
assert_eq!(out.gain.get(), 0.5);
assert_eq!(preference_gain(0), 0.0);
assert_eq!(preference_gain(256 | 50), 0.5);
use std::num::NonZero;
let source = SamplesBuffer::new(
NonZero::new(1).unwrap(),
NonZero::new(44100).unwrap(),
vec![3.0, -3.0, 0.4],
);
assert_eq!(Clamped(source).collect::<Vec<_>>(), [1.0, -1.0, 0.4]);
}
#[test]
fn unavailable_output_does_not_block_or_retry_per_click_and_only_retries_once() {
let calls = Arc::new(AtomicUsize::new(0));
let count = calls.clone();
let (notify, observed) = mpsc::channel();
let audio = UiAudio::with_factory(true, 50, move |_| {
count.fetch_add(1, Ordering::Relaxed);
notify.send(()).unwrap();
Err("no output / busy / unsupported format".into())
});
observed.recv_timeout(Duration::from_secs(3)).unwrap();
for _ in 0..1000 {
audio.play(UiCue::Click);
}
assert_eq!(calls.load(Ordering::Relaxed), 1);
audio.preferences(false, 50);
audio.preferences(true, 50);
observed.recv_timeout(Duration::from_secs(3)).unwrap();
audio.preferences(false, 50);
audio.preferences(true, 50);
for _ in 0..1000 {
audio.play(UiCue::Click);
}
assert_eq!(calls.load(Ordering::Relaxed), 2);
assert!(!audio.shared.ready.load(Ordering::Relaxed));
}
#[test]
fn stalled_factory_and_full_queue_never_block_submission_or_shutdown() {
let (entered, seen) = mpsc::channel();
let (release, gate) = mpsc::channel();
let gate = std::sync::Mutex::new(gate);
let audio = UiAudio::with_factory(true, 50, move |_| {
entered.send(()).unwrap();
let _ = gate.lock().unwrap().recv();
Err("stalled".into())
});
seen.recv_timeout(Duration::from_secs(3)).unwrap();
// Exercise full-channel handling even while the injected factory is stalled.
audio.shared.ready.store(true, Ordering::Relaxed);
for _ in 0..1000 {
audio.play(UiCue::Click);
}
assert!(matches!(
audio.tx.try_send(Command {
cue: UiCue::Click,
when: Instant::now(),
preferences: 306
}),
Err(mpsc::TrySendError::Full(_))
));
drop(audio); // Does not join the factory thread.
release.send(()).unwrap();
}
#[test]
fn stale_muted_and_previous_preference_commands_are_discarded() {
let now = Instant::now();
let command = Command {
cue: UiCue::Click,
when: now,
preferences: 306,
};
assert!(command.current(306, now + Duration::from_millis(99)));
assert!(!command.current(306, now + Duration::from_millis(101)));
assert!(!command.current(306 + (1 << 16), now));
assert!(!command.current(50, now));
assert!(!command.current(256, now));
}
#[test]
fn injected_disconnect_is_silent_mute_stops_active_voices_and_recovery_drops_backlog() {
struct TestVoice(Arc<AtomicUsize>);
impl Voice for TestVoice {
fn done(&self) -> bool {
false
}
fn stop(&self) {
self.0.fetch_add(1, Ordering::Relaxed);
}
fn volume(&self, _: f32) {}
}
struct TestOutput {
connected: Arc<AtomicBool>,
played: Arc<AtomicUsize>,
stopped: Arc<AtomicUsize>,
}
impl Output for TestOutput {
fn available(&self) -> bool {
self.connected.load(Ordering::Relaxed)
}
fn play(&self, _: SamplesBuffer, _: f32) -> Box<dyn Voice> {
self.played.fetch_add(1, Ordering::Relaxed);
Box::new(TestVoice(self.stopped.clone()))
}
}
fn until(f: impl Fn() -> bool) {
let deadline = Instant::now() + Duration::from_secs(3);
while !f() {
assert!(Instant::now() < deadline);
std::thread::sleep(Duration::from_millis(1));
}
}
let connected = Arc::new(AtomicBool::new(true));
let connection = connected.clone();
let played = Arc::new(AtomicUsize::new(0));
let plays = played.clone();
let stopped = Arc::new(AtomicUsize::new(0));
let stops = stopped.clone();
let audio = UiAudio::with_factory(true, 50, move |_| {
Ok(Box::new(TestOutput {
connected: connection.clone(),
played: plays.clone(),
stopped: stops.clone(),
}))
});
until(|| audio.shared.ready.load(Ordering::Relaxed));
audio.play(UiCue::Click);
until(|| played.load(Ordering::Relaxed) == 1);
audio.preferences(false, 50);
until(|| stopped.load(Ordering::Relaxed) == 1);
for _ in 0..100 {
audio.play(UiCue::Click);
}
audio.preferences(true, 50);
audio.play(UiCue::Tool);
until(|| played.load(Ordering::Relaxed) == 2);
connected.store(false, Ordering::Relaxed);
until(|| !audio.shared.ready.load(Ordering::Relaxed));
for _ in 0..100 {
audio.play(UiCue::Click);
}
assert_eq!(played.load(Ordering::Relaxed), 2);
connected.store(true, Ordering::Relaxed);
audio.preferences(false, 50);
audio.preferences(true, 50);
until(|| audio.shared.ready.load(Ordering::Relaxed));
audio.play(UiCue::Checkbox);
until(|| played.load(Ordering::Relaxed) == 3);
assert_eq!(played.load(Ordering::Relaxed), 3);
}