Adapt the self-join check and worker event lifetime from RustAudio/cpal#1187 (dccd6b464dc49267fa214ee168eb2b3c17a1ebf6). Keep shared OwnedHandle ownership so command submission also retains a valid event. Verify callback-thread destruction with a real WASAPI regression.
202 lines
6.6 KiB
Rust
202 lines
6.6 KiB
Rust
use super::*;
|
|
use crate::traits::{DeviceTrait, HostTrait};
|
|
use std::{
|
|
ffi::CString,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
const WORKER_DEADLINE: Duration = Duration::from_secs(2);
|
|
|
|
#[derive(Debug)]
|
|
enum WorkerExit {
|
|
Termination,
|
|
Finished,
|
|
Panicked,
|
|
}
|
|
|
|
fn stream(exit: WorkerExit) -> (Stream, CString) {
|
|
let name = CString::new(format!(
|
|
"Local\\cpal-lifecycle-{}-{exit:?}",
|
|
std::process::id()
|
|
))
|
|
.unwrap();
|
|
let event = unsafe {
|
|
Threading::CreateEventA(None, false, false, windows::core::PCSTR(name.as_ptr() as _))
|
|
}
|
|
.unwrap();
|
|
let (tx, rx) = channel();
|
|
let wait_for_exit = !matches!(exit, WorkerExit::Termination);
|
|
let worker = thread::spawn(move || match exit {
|
|
WorkerExit::Termination => assert!(matches!(rx.recv().unwrap(), Command::Terminate)),
|
|
WorkerExit::Finished => drop(rx),
|
|
WorkerExit::Panicked => {
|
|
drop(rx);
|
|
panic!("Injected worker failure");
|
|
}
|
|
});
|
|
if wait_for_exit {
|
|
let deadline = Instant::now() + WORKER_DEADLINE;
|
|
while !worker.is_finished() {
|
|
assert!(Instant::now() < deadline, "Worker failed to exit");
|
|
thread::yield_now();
|
|
}
|
|
}
|
|
let owned_event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) };
|
|
(
|
|
Stream {
|
|
thread: Some(worker),
|
|
commands: tx,
|
|
pending_scheduled_event: Arc::new(owned_event),
|
|
},
|
|
name,
|
|
)
|
|
}
|
|
|
|
fn assert_event_closed(exit: WorkerExit) {
|
|
let (stream, name) = stream(exit);
|
|
drop(stream);
|
|
// Another test can reuse a closed handle value; check the event's identity instead.
|
|
match unsafe {
|
|
Threading::OpenEventA(
|
|
Threading::EVENT_MODIFY_STATE,
|
|
false,
|
|
windows::core::PCSTR(name.as_ptr() as _),
|
|
)
|
|
} {
|
|
Ok(event) => {
|
|
let _event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) };
|
|
panic!("Stream destruction leaked its command event");
|
|
}
|
|
Err(error) => assert_eq!(
|
|
error.code(),
|
|
windows::core::HRESULT::from_win32(Foundation::ERROR_FILE_NOT_FOUND.0),
|
|
),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn normal_shutdown_closes_command_event() {
|
|
assert_event_closed(WorkerExit::Termination);
|
|
}
|
|
|
|
#[test]
|
|
fn completed_worker_still_closes_command_event() {
|
|
assert_event_closed(WorkerExit::Finished);
|
|
}
|
|
|
|
#[test]
|
|
fn panicked_worker_does_not_panic_in_drop_or_leak_event() {
|
|
assert_event_closed(WorkerExit::Panicked);
|
|
}
|
|
|
|
const WARMUP_CYCLES: usize = 4;
|
|
const MEASURED_CYCLES: usize = 16;
|
|
const CALLBACK_TIMEOUT: Duration = Duration::from_secs(3);
|
|
const POLL_INTERVAL: Duration = Duration::from_millis(10);
|
|
const SETTLE_TIME: Duration = Duration::from_millis(100);
|
|
|
|
#[test]
|
|
#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"]
|
|
fn native_callback_can_drop_stream_before_worker_exit() {
|
|
let host = crate::host::wasapi::Host::new().unwrap();
|
|
let device = host.default_output_device().unwrap();
|
|
let supported = device.default_output_config().unwrap();
|
|
assert_eq!(supported.sample_format(), SampleFormat::F32);
|
|
let (stream_tx, stream_rx) = channel::<Stream>();
|
|
let (result_tx, result_rx) = channel();
|
|
let output = device
|
|
.build_output_stream(
|
|
&supported.into(),
|
|
move |data: &mut [f32], _| {
|
|
data.fill(0.0);
|
|
let output = stream_rx.recv_timeout(CALLBACK_TIMEOUT).unwrap();
|
|
let event = Foundation::HANDLE(output.pending_scheduled_event.as_raw_handle() as _);
|
|
drop(output);
|
|
// The worker still needs its command event after this callback returns.
|
|
result_tx
|
|
.send(unsafe { Threading::SetEvent(event) })
|
|
.unwrap();
|
|
},
|
|
|error| eprintln!("Native callback error: {error}"),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
output.play().unwrap();
|
|
stream_tx.send(output).unwrap();
|
|
result_rx
|
|
.recv_timeout(CALLBACK_TIMEOUT)
|
|
.expect("Stream destruction blocked inside its own callback")
|
|
.expect("Stream destruction closed the live worker's command event");
|
|
assert_eq!(
|
|
result_rx.recv_timeout(CALLBACK_TIMEOUT),
|
|
Err(std::sync::mpsc::RecvTimeoutError::Disconnected),
|
|
"Worker did not exit after callback-thread destruction"
|
|
);
|
|
}
|
|
|
|
fn handle_count() -> u32 {
|
|
let mut count = 0;
|
|
unsafe { Threading::GetProcessHandleCount(Threading::GetCurrentProcess(), &mut count) }
|
|
.unwrap();
|
|
count
|
|
}
|
|
|
|
fn native_cycle(worker_exits_first: bool) {
|
|
let host = crate::default_host();
|
|
let device = host.default_output_device().unwrap();
|
|
let supported = device.default_output_config().unwrap();
|
|
assert_eq!(supported.sample_format(), SampleFormat::F32);
|
|
let (tx, rx) = channel();
|
|
let output = device
|
|
.build_output_stream(
|
|
&supported.into(),
|
|
move |data: &mut [f32], _| {
|
|
data.fill(0.0);
|
|
tx.send(()).unwrap();
|
|
// Test-only fault injection exits the real WASAPI worker before Drop.
|
|
assert!(!worker_exits_first, "Injected native worker exit");
|
|
},
|
|
|error| eprintln!("Native callback error: {error}"),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
output.play().unwrap();
|
|
rx.recv_timeout(CALLBACK_TIMEOUT).unwrap();
|
|
if worker_exits_first {
|
|
let deadline = Instant::now() + CALLBACK_TIMEOUT;
|
|
while output.play().is_ok() {
|
|
assert!(Instant::now() < deadline, "Worker receiver did not close");
|
|
thread::sleep(POLL_INTERVAL);
|
|
}
|
|
}
|
|
drop(output);
|
|
thread::sleep(SETTLE_TIME);
|
|
}
|
|
|
|
fn measured_cycles(worker_exits_first: bool) -> Vec<u32> {
|
|
let mut counts = vec![handle_count()];
|
|
for _ in 0..MEASURED_CYCLES {
|
|
native_cycle(worker_exits_first);
|
|
counts.push(handle_count());
|
|
}
|
|
counts
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"]
|
|
fn native_worker_exit_does_not_leak_process_handles() {
|
|
for _ in 0..WARMUP_CYCLES {
|
|
native_cycle(false);
|
|
}
|
|
let normal_before = measured_cycles(false);
|
|
let exited_first = measured_cycles(true);
|
|
let normal_after = measured_cycles(false);
|
|
eprintln!("normal_before={normal_before:?} worker_exits_first={exited_first:?} normal_after={normal_after:?}");
|
|
assert_eq!(normal_before.first(), normal_before.last());
|
|
assert_eq!(normal_after.first(), normal_after.last());
|
|
assert_eq!(
|
|
exited_first.first(),
|
|
exited_first.last(),
|
|
"Worker-exit-before-drop leaked native process handles"
|
|
);
|
|
}
|