adds integration tests for repeat

Author: dvdsk

src/source/mod.rs

@@ -159,7 +159,7 @@ pub use self::noise::{pink, white, PinkNoise, WhiteNoise};
 pub trait Source: Iterator<Item = Sample> {
     /// Whether the value of `channels()` and/or `sample_rate()` have changed.
     /// This is true before the next call to `Source::next`. After that
-    /// `Source::next` call this will be false again. 
+    /// `Source::next` call this will be false again.
     ///
     /// The value before the first call to next is not defined.
     fn parameters_changed(&self) -> bool;
@@ -203,7 +203,7 @@ pub trait Source: Iterator<Item = Sample> {
     where
         Self: Sized,
     {
-        repeat::repeat(self)
+        Repeat::new(self)
     }
 
     /// Takes a certain duration of this source and then stops.

src/source/repeat.rs

@@ -7,18 +7,6 @@ use super::SeekError;
 use crate::common::{ChannelCount, SampleRate};
 use crate::Source;
 
-/// Internal function that builds a `Repeat` object.
-pub fn repeat<I>(input: I) -> Repeat<I>
-where
-    I: Source,
-{
-    let input = input.buffered();
-    Repeat {
-        inner: PeekableSource::new(input.clone()),
-        next: input,
-    }
-}
-
 /// A source that repeats the given source.
 pub struct Repeat<I>
 where
@@ -28,10 +16,17 @@ where
     next: Buffered<I>,
 }
 
-impl<I> Iterator for Repeat<I>
-where
-    I: Source,
-{
+impl<I: Source> Repeat<I> {
+    pub(crate) fn new(input: I) -> Repeat<I> {
+        let input = input.buffered();
+        Repeat {
+            inner: PeekableSource::new(input.clone()),
+            next: input,
+        }
+    }
+}
+
+impl<I: Source> Iterator for Repeat<I> {
     type Item = <I as Iterator>::Item;
 
     #[inline]

tests/repeat.rs

@@ -0,0 +1,56 @@
+use rodio::Source;
+use test_support::{TestSource, TestSpan};
+
+mod test_support;
+
+#[test]
+fn frame_boundray_at_start_of_repeat() {
+    let source = TestSource::new()
+        .with_span(TestSpan::from_samples((0..10).map(|n| n as f32)).with_sample_count(10))
+        .with_span(TestSpan::from_samples((10..20).map(|n| n as f32)).with_sample_count(10));
+
+    let mut repeating = source.clone().repeat_infinite();
+    repeating.by_ref().take(source.len()).count();
+    assert!(repeating.parameters_changed());
+
+    assert!(repeating.next().is_some());
+    assert!(!repeating.parameters_changed());
+}
+
+#[test]
+fn parameters_identical_on_second_run() {
+    let source = TestSource::new()
+        .with_span(TestSpan::from_samples((0..10).map(|n| n as f32)).with_sample_count(10))
+        .with_span(TestSpan::from_samples((10..20).map(|n| n as f32)).with_sample_count(10));
+
+    let mut repeating = source.clone().repeat_infinite();
+
+    let mut first_run_params = Vec::new();
+    let mut second_run_params = Vec::new();
+
+    for params in [&mut first_run_params, &mut second_run_params] {
+        for _ in 0..source.len() {
+            assert!(repeating.by_ref().next().is_some());
+            params.push((
+                repeating.parameters_changed(),
+                repeating.channels(),
+                repeating.sample_rate(),
+            ));
+        }
+    }
+
+    assert_eq!(first_run_params, second_run_params);
+}
+
+#[test]
+fn same_samples_on_second_run() {
+    let source = TestSource::new()
+        .with_span(TestSpan::from_samples((0..10).map(|n| n as f32)).with_sample_count(10))
+        .with_span(TestSpan::from_samples((10..20).map(|n| n as f32)).with_sample_count(10));
+
+    let mut repeating = source.clone().repeat_infinite();
+    let first_run: Vec<_> = repeating.by_ref().take(source.len()).collect();
+    let second_run: Vec<_> = repeating.take(source.len()).collect();
+
+    assert_eq!(first_run, second_run);
+}