chore: test shuffle with first

Author: photovoltex

connect/src/shuffle_vec.rs

@@ -56,22 +56,14 @@ impl<T> From<Vec<T>> for ShuffleVec<T> {
 }
 
 impl<T> ShuffleVec<T> {
-    pub fn shuffle_with_seed<F: Fn(&T) -> bool>(
-        &mut self,
-        seed: u64,
-        is_first: F,
-    ) -> Option<usize> {
+    pub fn shuffle_with_seed<F: Fn(&T) -> bool>(&mut self, seed: u64, is_first: F) {
         self.shuffle_with_rng(SmallRng::seed_from_u64(seed), is_first)
     }
 
-    pub fn shuffle_with_rng<F: Fn(&T) -> bool>(
-        &mut self,
-        mut rng: impl Rng,
-        is_first: F,
-    ) -> Option<usize> {
-        if self.vec.len() < 3 {
-            info!("skipped shuffling for less than three items");
-            return None;
+    pub fn shuffle_with_rng<F: Fn(&T) -> bool>(&mut self, mut rng: impl Rng, is_first: F) {
+        if self.vec.len() <= 1 {
+            info!("skipped shuffling for less or equal one item");
+            return;
         }
 
         if self.indices.is_some() {
@@ -95,8 +87,6 @@ impl<T> ShuffleVec<T> {
         if let Some(first_pos) = self.original_first_position {
             self.vec.swap(0, first_pos)
         }
-
-        self.original_first_position
     }
 
     pub fn unshuffle(&mut self) {
@@ -123,25 +113,86 @@ impl<T> ShuffleVec<T> {
 mod test {
     use super::*;
     use rand::Rng;
+    use std::ops::Range;
 
-    #[test]
-    fn test_shuffle_with_seed() {
-        let seed = rand::rng().random_range(0..10000000000000);
+    fn base(range: Range<usize>) -> (ShuffleVec<usize>, u64) {
+        let seed = rand::rng().random_range(0..10_000_000_000_000);
+
+        let vec = range.collect::<Vec<_>>();
+        (vec.into(), seed)
+    }
 
-        let vec = (0..100).collect::<Vec<_>>();
-        let base_vec: ShuffleVec<i32> = vec.into();
+    #[test]
+    fn test_shuffle_without_first() {
+        let (base_vec, seed) = base(0..100);
 
         let mut shuffled_vec = base_vec.clone();
         shuffled_vec.shuffle_with_seed(seed, |_| false);
 
         let mut different_shuffled_vec = base_vec.clone();
         different_shuffled_vec.shuffle_with_seed(seed, |_| false);
 
-        assert_eq!(shuffled_vec, different_shuffled_vec);
+        assert_eq!(
+            shuffled_vec, different_shuffled_vec,
+            "shuffling with the same seed has the same result"
+        );
 
         let mut unshuffled_vec = shuffled_vec.clone();
         unshuffled_vec.unshuffle();
 
-        assert_eq!(base_vec, unshuffled_vec);
+        assert_eq!(
+            base_vec, unshuffled_vec,
+            "unshuffle restores the original state"
+        );
+    }
+
+    #[test]
+    fn test_shuffle_with_first() {
+        const MAX_RANGE: usize = 200;
+
+        let (base_vec, seed) = base(0..MAX_RANGE);
+        let rand_first = rand::rng().random_range(0..MAX_RANGE);
+
+        let mut shuffled_with_first = base_vec.clone();
+        shuffled_with_first.shuffle_with_seed(seed, |i| i == &rand_first);
+
+        assert_eq!(
+            Some(&rand_first),
+            shuffled_with_first.first(),
+            "after shuffling the first is expected to be the given item"
+        );
+
+        let mut shuffled_without_first = base_vec.clone();
+        shuffled_without_first.shuffle_with_seed(seed, |_| false);
+
+        let mut switched_positions = Vec::with_capacity(2);
+        for (i, without_first_value) in shuffled_without_first.iter().enumerate() {
+            if without_first_value != &shuffled_with_first[i] {
+                switched_positions.push(i);
+            } else {
+                assert_eq!(
+                    without_first_value, &shuffled_with_first[i],
+                    "shuffling with the same seed has the same result"
+                );
+            }
+        }
+
+        assert_eq!(
+            switched_positions.len(),
+            2,
+            "only the switched positions should be different"
+        );
+
+        assert_eq!(
+            shuffled_with_first[switched_positions[0]],
+            shuffled_without_first[switched_positions[1]],
+            "the switched values should be equal"
+        );
+
+        assert_eq!(
+            shuffled_with_first[switched_positions[1]],
+            shuffled_without_first[switched_positions[0]],
+            "the switched values should be equal"
+        )
     }
 }