refactor tests, add seek beyond stream test

src/decoder/flac.rs

@@ -88,7 +88,7 @@ where
 
     #[inline]
     fn can_seek(&self) -> bool {
-        true
+        false
     }
 }
 

src/decoder/symphonia.rs

@@ -153,7 +153,7 @@ impl Source for SymphoniaDecoder {
             .seek(
                 SeekMode::Accurate,
                 SeekTo::Time {
-                    time: Time::new(pos.as_secs(), dbg!(pos_fract)),
+                    time: Time::new(pos.as_secs(), pos_fract),
                     track_id: None,
                 },
             )

tests/seek.rs

@@ -1,21 +1,37 @@
-use std::io::BufReader;
+use std::io::{BufReader, Read, Seek};
 use std::path::Path;
+use std::sync::Once;
 use std::time::Duration;
 
-use rodio::source::SeekNotSupported;
+use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
 
-fn play_and_seek(asset_path: &Path) -> Result<(), SeekNotSupported> {
-    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
-    let sink = rodio::Sink::try_new(&handle).unwrap();
+static mut STREAM: Option<OutputStream> = None;
+static mut STREAM_HANDLE: Option<OutputStreamHandle> = None;
+static INIT: Once = Once::new();
 
-    let file = std::fs::File::open(asset_path).unwrap();
-    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
-    sink.try_seek(Duration::from_secs(2))
+fn global_stream_handle() -> &'static OutputStreamHandle {
+    // mutable global access is guarded by Once therefore
+    // can only happen Once and will not race
+    unsafe {
+        INIT.call_once(|| {
+            let (stream, handle) = rodio::OutputStream::try_default().unwrap();
+            STREAM = Some(stream);
+            STREAM_HANDLE = Some(handle);
+        });
+        STREAM_HANDLE.as_ref().unwrap()
+    }
 }
 
-#[test]
-fn seek_returns_err_if_unsupported() {
-    let formats = [
+fn sink_and_decoder(format: &str) -> (Sink, Decoder<impl Read + Seek>) {
+    let sink = rodio::Sink::try_new(global_stream_handle()).unwrap();
+    let asset = Path::new("assets/music").with_extension(format);
+    let file = std::fs::File::open(asset).unwrap();
+    let decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
+    (sink, decoder)
+}
+
+fn format_decoder_info() -> &'static [(&'static str, bool, &'static str)] {
+    &[
         #[cfg(feature = "minimp3")]
         ("mp3", true, "minimp3"),
         #[cfg(feature = "symphonia-mp3")]
@@ -34,12 +50,30 @@ fn seek_returns_err_if_unsupported() {
         ("flac", true, "symphonia"),
         #[cfg(feature = "symphonia-isomp4")]
         ("m4a", true, "_"),
-    ];
+    ]
+}
 
-    for (format, supported, decoder) in formats {
-        println!("trying: {format} by {decoder}, should support seek: {supported}");
-        let asset = Path::new("assets/music").with_extension(format);
-        let res = play_and_seek(&asset);
+#[test]
+fn seek_returns_err_if_unsupported() {
+    for (format, supported, decoder) in format_decoder_info().iter().cloned() {
+        println!("trying: {format},\t\tby: {decoder},\t\tshould support seek: {supported}");
+        let (sink, decoder) = sink_and_decoder(format);
+        assert_eq!(decoder.can_seek(), supported);
+        sink.append(decoder);
+        let res = sink.try_seek(Duration::from_secs(2));
         assert_eq!(res.is_ok(), supported);
     }
 }
+
+#[test]
+fn seek_beyond_end_does_not_crash() {
+    for (format, _, decoder_name) in format_decoder_info().iter().cloned() {
+        let (sink, decoder) = sink_and_decoder(format);
+        if !decoder.can_seek() {
+            continue;
+        }
+        println!("seeking beyond end for: {format}\t decoded by: {decoder_name}");
+        sink.append(decoder);
+        sink.try_seek(Duration::from_secs(999)).unwrap();
+    }
+}