Merge pull request #73 from orxfun/rand-clippy-fixes

clippy rand fixes

Author: orxfun

src/algorithms/binary_search.rs

@@ -31,111 +31,3 @@ where
 
     Err(fragment_begin_idx)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{test_all_growth_types, Growth, SplitVec};
-    use orx_pinned_vec::PinnedVec;
-
-    fn get_compare(value: usize) -> impl FnMut(&usize) -> Ordering {
-        move |x: &usize| x.cmp(&value)
-    }
-
-    #[test]
-    fn bin_search_empty() {
-        let cmp = get_compare(42);
-
-        let fragments = alloc::vec![];
-        let result = binary_search_by(&fragments, cmp);
-        assert_eq!(result, Err(0));
-    }
-
-    #[test]
-    fn bin_search_empty_first_fragment() {
-        let cmp = get_compare(42);
-
-        let fragments = alloc::vec![alloc::vec![].into()];
-        let result = binary_search_by(&fragments, cmp);
-        assert_eq!(result, Err(0));
-    }
-
-    #[test]
-    fn bin_search_empty_second_fragment() {
-        let fragments = alloc::vec![alloc::vec![1, 4, 5].into(), alloc::vec![].into()];
-
-        let result = binary_search_by(&fragments, get_compare(0));
-        assert_eq!(result, Err(0));
-
-        let result = binary_search_by(&fragments, get_compare(2));
-        assert_eq!(result, Err(1));
-
-        let result = binary_search_by(&fragments, get_compare(42));
-        assert_eq!(result, Err(3));
-
-        let result = binary_search_by(&fragments, get_compare(1));
-        assert_eq!(result, Ok(0));
-
-        let result = binary_search_by(&fragments, get_compare(4));
-        assert_eq!(result, Ok(1));
-
-        let result = binary_search_by(&fragments, get_compare(5));
-        assert_eq!(result, Ok(2));
-    }
-
-    #[test]
-    fn bin_search_three_fragments() {
-        let fragments = alloc::vec![
-            alloc::vec![1, 4, 5].into(),
-            alloc::vec![7].into(),
-            alloc::vec![9, 10].into()
-        ];
-
-        let search = |x| binary_search_by(&fragments, get_compare(x));
-
-        assert_eq!(search(0), Err(0));
-        assert_eq!(search(1), Ok(0));
-        assert_eq!(search(2), Err(1));
-        assert_eq!(search(3), Err(1));
-        assert_eq!(search(4), Ok(1));
-        assert_eq!(search(5), Ok(2));
-        assert_eq!(search(6), Err(3));
-        assert_eq!(search(7), Ok(3));
-        assert_eq!(search(8), Err(4));
-        assert_eq!(search(9), Ok(4));
-        assert_eq!(search(10), Ok(5));
-        assert_eq!(search(11), Err(6));
-    }
-
-    #[test]
-    fn bin_search_randomized() {
-        use rand::prelude::*;
-        use rand_chacha::ChaCha8Rng;
-
-        fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
-            let mut rng = ChaCha8Rng::seed_from_u64(8654);
-            let mut ref_vec = alloc::vec![];
-            let mut idx = 0;
-            while ref_vec.len() < 1033 {
-                if rng.gen::<f32>() < 0.85 {
-                    ref_vec.push(idx);
-                    vec.push(idx);
-                }
-                idx += 1;
-            }
-
-            for i in 0..(idx + 10) {
-                assert_eq!(
-                    vec.binary_search_by(|x| x.cmp(&i)),
-                    ref_vec.binary_search_by(|x| x.cmp(&i)),
-                );
-                assert_eq!(vec.binary_search(&i), ref_vec.binary_search(&i));
-                assert_eq!(
-                    vec.binary_search_by_key(&(2 * i), |x| 2 * x),
-                    ref_vec.binary_search_by_key(&(2 * i), |x| 2 * x),
-                );
-            }
-        }
-        test_all_growth_types!(test);
-    }
-}

src/algorithms/in_place_sort.rs

@@ -74,7 +74,11 @@ where
     }
 }
 
-fn find_position_to_insert<T, F>(fragment: &[T], compare: &mut F, value: &T) -> Option<usize>
+pub(super) fn find_position_to_insert<T, F>(
+    fragment: &[T],
+    compare: &mut F,
+    value: &T,
+) -> Option<usize>
 where
     F: FnMut(&T, &T) -> Ordering,
 {
@@ -109,136 +113,3 @@ where
         },
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Doubling, Growth, Linear, Recursive};
-    use alloc::vec::Vec;
-    use test_case::test_case;
-
-    #[test]
-    fn insertion_position() {
-        let fragment: Fragment<u32> = alloc::vec![4, 7, 9, 13, 16, 17, 23].into();
-
-        let mut c = |a: &u32, b: &u32| a.cmp(b);
-        let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
-
-        assert_eq!(pos(&0), None);
-        assert_eq!(pos(&3), None);
-        assert_eq!(pos(&4), None);
-
-        assert_eq!(pos(&5), Some(1));
-        assert_eq!(pos(&6), Some(1));
-        assert_eq!(pos(&7), Some(1));
-
-        assert_eq!(pos(&8), Some(2));
-        assert_eq!(pos(&9), Some(2));
-
-        assert_eq!(pos(&10), Some(3));
-        assert_eq!(pos(&11), Some(3));
-        assert_eq!(pos(&12), Some(3));
-        assert_eq!(pos(&13), Some(3));
-
-        assert_eq!(pos(&14), Some(4));
-        assert_eq!(pos(&15), Some(4));
-        assert_eq!(pos(&16), Some(4));
-
-        assert_eq!(pos(&17), Some(5));
-
-        assert_eq!(pos(&18), Some(6));
-        assert_eq!(pos(&19), Some(6));
-        assert_eq!(pos(&20), Some(6));
-        assert_eq!(pos(&21), Some(6));
-        assert_eq!(pos(&22), Some(6));
-        assert_eq!(pos(&23), Some(6));
-
-        assert_eq!(pos(&24), Some(7));
-        assert_eq!(pos(&25), Some(7));
-        assert_eq!(pos(&26), Some(7));
-        assert_eq!(pos(&100), Some(7));
-    }
-
-    #[test]
-    fn insertion_position_with_ties() {
-        let mut c = |a: &u32, b: &u32| a.cmp(b);
-
-        let fragment: Fragment<u32> = alloc::vec![4, 7, 13, 13, 13, 17, 23].into();
-        let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
-        assert_eq!(pos(&13), Some(2));
-
-        let fragment: Fragment<u32> = alloc::vec![4, 7, 13, 13, 23, 23, 23].into();
-        let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
-        assert_eq!(pos(&23), Some(4));
-
-        let fragment: Fragment<u32> = alloc::vec![4, 4, 13, 13, 23, 23, 23].into();
-        let mut pos = |val: &u32| find_position_to_insert(&fragment, &mut c, val);
-        assert_eq!(pos(&4), None);
-    }
-
-    #[test]
-    fn sort_simple() {
-        let mut c = |a: &u32, b: &u32| a.cmp(b);
-
-        let mut fragments: Vec<Fragment<u32>> = alloc::vec![
-            alloc::vec![2, 4].into(),
-            alloc::vec![0, 5, 6].into(),
-            alloc::vec![1, 3].into()
-        ];
-
-        in_place_sort_by(&mut fragments, &mut c);
-
-        assert_is_sorted(fragments);
-    }
-
-    #[test_case(Doubling)]
-    #[test_case(Recursive)]
-    #[test_case(Linear::new(10))]
-    fn sort_growth(growth: impl Growth) {
-        let mut c = |a: &i32, b: &i32| a.cmp(b);
-
-        let num_fragments = 10;
-        let mut fragments: Vec<Fragment<_>> = alloc::vec![];
-
-        let mut len = 0;
-        for _ in 0..num_fragments {
-            let fragment_capacities: Vec<_> = fragments.iter().map(|x| x.capacity()).collect();
-            let mut fragment =
-                Fragment::new(growth.new_fragment_capacity_from(fragment_capacities.into_iter()));
-            for i in 0..fragment.capacity() {
-                let i = len + i;
-                let value = match i % 3 {
-                    0 => i as i32,
-                    1 => 42,
-                    _ => -(i as i32),
-                };
-                fragment.push(value);
-            }
-
-            assert_eq!(fragment.len(), fragment.capacity());
-            len += fragment.len();
-            fragments.push(fragment);
-        }
-
-        assert_eq!(fragments.len(), num_fragments);
-
-        in_place_sort_by(&mut fragments, &mut c);
-
-        assert_is_sorted(fragments);
-    }
-
-    fn assert_is_sorted<T: Ord>(fragments: Vec<Fragment<T>>) {
-        let flattened: Vec<T> = fragments.into_iter().flat_map(|x| Vec::from(x)).collect();
-
-        if flattened.is_empty() {
-            return;
-        }
-
-        let mut curr = &flattened[0];
-        for i in 1..flattened.len() {
-            let cmp = curr.cmp(&flattened[i]);
-            assert!(cmp != Greater);
-            curr = &flattened[i];
-        }
-    }
-}

src/algorithms/mod.rs

@@ -1,2 +1,5 @@
+#[cfg(test)]
+mod tests;
+
 pub mod binary_search;
 pub mod in_place_sort;

src/algorithms/tests/binary_search.rs

@@ -0,0 +1,105 @@
+use crate::algorithms::binary_search::binary_search_by;
+use crate::{test_all_growth_types, Growth, SplitVec};
+use core::cmp::Ordering;
+use orx_pinned_vec::PinnedVec;
+
+fn get_compare(value: usize) -> impl FnMut(&usize) -> Ordering {
+    move |x: &usize| x.cmp(&value)
+}
+
+#[test]
+fn bin_search_empty() {
+    let cmp = get_compare(42);
+
+    let fragments = alloc::vec![];
+    let result = binary_search_by(&fragments, cmp);
+    assert_eq!(result, Err(0));
+}
+
+#[test]
+fn bin_search_empty_first_fragment() {
+    let cmp = get_compare(42);
+
+    let fragments = alloc::vec![alloc::vec![].into()];
+    let result = binary_search_by(&fragments, cmp);
+    assert_eq!(result, Err(0));
+}
+
+#[test]
+fn bin_search_empty_second_fragment() {
+    let fragments = alloc::vec![alloc::vec![1, 4, 5].into(), alloc::vec![].into()];
+
+    let result = binary_search_by(&fragments, get_compare(0));
+    assert_eq!(result, Err(0));
+
+    let result = binary_search_by(&fragments, get_compare(2));
+    assert_eq!(result, Err(1));
+
+    let result = binary_search_by(&fragments, get_compare(42));
+    assert_eq!(result, Err(3));
+
+    let result = binary_search_by(&fragments, get_compare(1));
+    assert_eq!(result, Ok(0));
+
+    let result = binary_search_by(&fragments, get_compare(4));
+    assert_eq!(result, Ok(1));
+
+    let result = binary_search_by(&fragments, get_compare(5));
+    assert_eq!(result, Ok(2));
+}
+
+#[test]
+fn bin_search_three_fragments() {
+    let fragments = alloc::vec![
+        alloc::vec![1, 4, 5].into(),
+        alloc::vec![7].into(),
+        alloc::vec![9, 10].into()
+    ];
+
+    let search = |x| binary_search_by(&fragments, get_compare(x));
+
+    assert_eq!(search(0), Err(0));
+    assert_eq!(search(1), Ok(0));
+    assert_eq!(search(2), Err(1));
+    assert_eq!(search(3), Err(1));
+    assert_eq!(search(4), Ok(1));
+    assert_eq!(search(5), Ok(2));
+    assert_eq!(search(6), Err(3));
+    assert_eq!(search(7), Ok(3));
+    assert_eq!(search(8), Err(4));
+    assert_eq!(search(9), Ok(4));
+    assert_eq!(search(10), Ok(5));
+    assert_eq!(search(11), Err(6));
+}
+
+#[test]
+fn bin_search_randomized() {
+    use rand::prelude::*;
+    use rand_chacha::ChaCha8Rng;
+
+    fn test<G: Growth>(mut vec: SplitVec<usize, G>) {
+        let mut rng = ChaCha8Rng::seed_from_u64(8654);
+        let mut ref_vec = alloc::vec![];
+        let mut idx = 0;
+        while ref_vec.len() < 1033 {
+            if rng.random::<f32>() < 0.85 {
+                ref_vec.push(idx);
+                vec.push(idx);
+            }
+            idx += 1;
+        }
+
+        for i in 0..(idx + 10) {
+            assert_eq!(
+                vec.binary_search_by(|x| x.cmp(&i)),
+                ref_vec.binary_search_by(|x| x.cmp(&i)),
+            );
+            assert_eq!(vec.binary_search(&i), ref_vec.binary_search(&i));
+            assert_eq!(
+                vec.binary_search_by_key(&(2 * i), |x| 2 * x),
+                ref_vec.binary_search_by_key(&(2 * i), |x| 2 * x),
+            );
+        }
+    }
+    test_all_growth_types!(test);
+}