Rewrite Tests for Sorting Algorithms Idiomatically (#479)

Author: agatekartik

src/lib.rs

@@ -23,15 +23,13 @@ mod tests {
         //descending
         let mut ve1 = vec![6, 5, 4, 3, 2, 1];
         sorting::quick_sort(&mut ve1);
-        for i in 0..ve1.len() - 1 {
-            assert!(ve1[i] <= ve1[i + 1]);
-        }
+
+        assert!(sorting::is_sorted(&ve1));
 
         //pre-sorted
         let mut ve2 = vec![1, 2, 3, 4, 5, 6];
         sorting::quick_sort(&mut ve2);
-        for i in 0..ve2.len() - 1 {
-            assert!(ve2[i] <= ve2[i + 1]);
-        }
+
+        assert!(sorting::is_sorted(&ve2));
     }
 }

src/sorting/bead_sort.rs

@@ -3,11 +3,11 @@
 pub fn bead_sort(a: &mut [usize]) {
     // Find the maximum element
     let mut max = a[0];
-    for i in 1..a.len() {
+    (1..a.len()).for_each(|i| {
         if a[i] > max {
             max = a[i];
         }
-    }
+    });
 
     // allocating memory
     let mut beads = vec![vec![0; max]; a.len()];
@@ -22,10 +22,10 @@ pub fn bead_sort(a: &mut [usize]) {
     // move down the beads
     for j in 0..max {
         let mut sum = 0;
-        for i in 0..a.len() {
+        (0..a.len()).for_each(|i| {
             sum += beads[i][j];
             beads[i][j] = 0;
-        }
+        });
 
         for k in ((a.len() - sum)..a.len()).rev() {
             a[k] = j + 1;
@@ -36,24 +36,24 @@ pub fn bead_sort(a: &mut [usize]) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn descending() {
         //descending
         let mut ve1: [usize; 5] = [5, 4, 3, 2, 1];
+        let cloned = ve1;
         bead_sort(&mut ve1);
-        for i in 0..ve1.len() - 1 {
-            assert!(ve1[i] <= ve1[i + 1]);
-        }
+        assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
     #[test]
     fn mix_values() {
         //pre-sorted
         let mut ve2: [usize; 5] = [7, 9, 6, 2, 3];
+        let cloned = ve2;
         bead_sort(&mut ve2);
-        for j in 0..ve2.len() - 1 {
-            assert!(ve2[j] <= ve2[j + 1]);
-        }
+        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
 }

src/sorting/bitonic_sort.rs

@@ -35,19 +35,17 @@ mod tests {
     fn descending() {
         //descending
         let mut ve1 = vec![6, 5, 4, 3];
+        let cloned = ve1.clone();
         bitonic_sort(&mut ve1, 0, 4, 1);
-        for i in 0..ve1.len() - 1 {
-            assert!(ve1[i] <= ve1[i + 1]);
-        }
+        assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
     #[test]
     fn ascending() {
         //pre-sorted
         let mut ve2 = vec![1, 2, 3, 4];
+        let cloned = ve2.clone();
         bitonic_sort(&mut ve2, 0, 4, 0);
-        for i in 0..ve2.len() - 1 {
-            assert!(ve2[i] >= ve2[i + 1]);
-        }
+        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
 }

src/sorting/bubble_sort.rs

@@ -18,28 +18,32 @@ pub fn bubble_sort<T: Ord>(arr: &mut [T]) {
 
 #[cfg(test)]
 mod tests {
-    use super::super::is_sorted;
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn descending() {
         //descending
         let mut ve1 = vec![6, 5, 4, 3, 2, 1];
+        let cloned = ve1.clone();
         bubble_sort(&mut ve1);
-        assert!(is_sorted(&ve1));
+        assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
     #[test]
     fn ascending() {
         //pre-sorted
         let mut ve2 = vec![1, 2, 3, 4, 5, 6];
+        let cloned = ve2.clone();
         bubble_sort(&mut ve2);
-        assert!(is_sorted(&ve2));
+        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
     #[test]
     fn empty() {
         let mut ve3: Vec<usize> = vec![];
+        let cloned = ve3.clone();
         bubble_sort(&mut ve3);
-        assert!(is_sorted(&ve3));
+        assert!(is_sorted(&ve3) && have_same_elements(&ve3, &cloned));
     }
 }

src/sorting/bucket_sort.rs

@@ -33,48 +33,55 @@ pub fn bucket_sort(arr: &[usize]) -> Vec<usize> {
 
 #[cfg(test)]
 mod tests {
-    use super::super::is_sorted;
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn empty() {
         let arr: [usize; 0] = [];
+        let cloned = arr;
         let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
+        assert!(is_sorted(&res) && have_same_elements(&res, &cloned));
     }
 
     #[test]
     fn one_element() {
         let arr: [usize; 1] = [4];
+        let cloned = arr;
         let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
+        assert!(is_sorted(&res) && have_same_elements(&res, &cloned));
     }
 
     #[test]
     fn already_sorted() {
-        let arr: [usize; 3] = [10, 9, 105];
+        let arr: [usize; 3] = [10, 19, 105];
+        let cloned = arr;
         let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
+        assert!(is_sorted(&res) && have_same_elements(&res, &cloned));
     }
 
     #[test]
     fn basic() {
         let arr: [usize; 4] = [35, 53, 1, 0];
+        let cloned = arr;
         let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
+        assert!(is_sorted(&res) && have_same_elements(&res, &cloned));
     }
 
     #[test]
     fn odd_number_of_elements() {
         let arr: Vec<usize> = vec![1, 21, 5, 11, 58];
+        let cloned = arr.clone();
         let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
+        assert!(is_sorted(&res) && have_same_elements(&res, &cloned));
     }
 
     #[test]
     fn repeated_elements() {
         let arr: Vec<usize> = vec![542, 542, 542, 542];
+        let cloned = arr.clone();
         let res = bucket_sort(&arr);
-        assert!(is_sorted(&res));
+        assert!(is_sorted(&res) && have_same_elements(&res, &cloned));
     }
 }

src/sorting/cocktail_shaker_sort.rs

@@ -37,32 +37,38 @@ pub fn cocktail_shaker_sort<T: Ord>(arr: &mut [T]) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn basic() {
         let mut arr = vec![5, 2, 1, 3, 4, 6];
+        let cloned = arr.clone();
         cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1, 2, 3, 4, 5, 6]);
+        assert!(is_sorted(&arr) && have_same_elements(&arr, &cloned));
     }
 
     #[test]
     fn empty() {
         let mut arr = Vec::<i32>::new();
+        let cloned = arr.clone();
         cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![]);
+        assert!(is_sorted(&arr) && have_same_elements(&arr, &cloned));
     }
 
     #[test]
     fn one_element() {
         let mut arr = vec![1];
+        let cloned = arr.clone();
         cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1]);
+        assert!(is_sorted(&arr) && have_same_elements(&arr, &cloned));
     }
 
     #[test]
     fn pre_sorted() {
         let mut arr = vec![1, 2, 3, 4, 5, 6];
+        let cloned = arr.clone();
         cocktail_shaker_sort(&mut arr);
-        assert_eq!(arr, vec![1, 2, 3, 4, 5, 6]);
+        assert!(is_sorted(&arr) && have_same_elements(&arr, &cloned));
     }
 }

src/sorting/comb_sort.rs

@@ -22,34 +22,33 @@ pub fn comb_sort<T: Ord>(arr: &mut [T]) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn descending() {
         //descending
         let mut ve1 = vec![6, 5, 4, 3, 2, 1];
+        let cloned = ve1.clone();
         comb_sort(&mut ve1);
-        for i in 0..ve1.len() - 1 {
-            assert!(ve1[i] <= ve1[i + 1]);
-        }
+        assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
     #[test]
     fn ascending() {
         //pre-sorted
         let mut ve2 = vec![1, 2, 3, 4, 5, 6];
+        let cloned = ve2.clone();
         comb_sort(&mut ve2);
-        for i in 0..ve2.len() - 1 {
-            assert!(ve2[i] <= ve2[i + 1]);
-        }
+        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
 
     #[test]
     fn duplicates() {
         //pre-sorted
         let mut ve3 = vec![2, 2, 2, 2, 2, 1];
+        let cloned = ve3.clone();
         comb_sort(&mut ve3);
-        for i in 0..ve3.len() - 1 {
-            assert!(ve3[i] <= ve3[i + 1]);
-        }
+        assert!(is_sorted(&ve3) && have_same_elements(&ve3, &cloned));
     }
 }

src/sorting/counting_sort.rs

@@ -51,38 +51,43 @@ pub fn generic_counting_sort<T: Into<u64> + From<u8> + AddAssign + Copy>(
 
 #[cfg(test)]
 mod test {
-    use super::super::is_sorted;
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
 
     #[test]
     fn counting_sort_descending() {
         let mut ve1 = vec![6, 5, 4, 3, 2, 1];
+        let cloned = ve1.clone();
         counting_sort(&mut ve1, 6);
 
-        assert!(is_sorted(&ve1));
+        assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
     #[test]
     fn counting_sort_pre_sorted() {
         let mut ve2 = vec![1, 2, 3, 4, 5, 6];
+        let cloned = ve2.clone();
         counting_sort(&mut ve2, 6);
 
-        assert!(is_sorted(&ve2));
+        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
 
     #[test]
     fn generic_counting_sort() {
         let mut ve1: Vec<u8> = vec![100, 30, 60, 10, 20, 120, 1];
+        let cloned = ve1.clone();
         super::generic_counting_sort(&mut ve1, 120);
 
-        assert!(is_sorted(&ve1));
+        assert!(is_sorted(&ve1) && have_same_elements(&ve1, &cloned));
     }
 
     #[test]
     fn presorted_u64_counting_sort() {
         let mut ve2: Vec<u64> = vec![1, 2, 3, 4, 5, 6];
+        let cloned = ve2.clone();
         super::generic_counting_sort(&mut ve2, 6);
 
-        assert!(is_sorted(&ve2));
+        assert!(is_sorted(&ve2) && have_same_elements(&ve2, &cloned));
     }
 }

src/sorting/cycle_sort.rs

@@ -33,21 +33,28 @@ pub fn cycle_sort(arr: &mut [i32]) {
 
 #[cfg(test)]
 mod tests {
-    use super::super::is_sorted;
+
     use super::*;
+    use crate::sorting::have_same_elements;
+    use crate::sorting::is_sorted;
+
     #[test]
     fn it_works() {
         let mut arr1 = [6, 5, 4, 3, 2, 1];
+        let cloned = arr1;
         cycle_sort(&mut arr1);
-        assert!(is_sorted(&arr1));
+        assert!(is_sorted(&arr1) && have_same_elements(&arr1, &cloned));
         arr1 = [12, 343, 21, 90, 3, 21];
+        let cloned = arr1;
         cycle_sort(&mut arr1);
-        assert!(is_sorted(&arr1));
+        assert!(is_sorted(&arr1) && have_same_elements(&arr1, &cloned));
         let mut arr2 = [1];
+        let cloned = arr2;
         cycle_sort(&mut arr2);
-        assert!(is_sorted(&arr2));
+        assert!(is_sorted(&arr2) && have_same_elements(&arr2, &cloned));
         let mut arr3 = [213, 542, 90, -23412, -32, 324, -34, 3324, 54];
+        let cloned = arr3;
         cycle_sort(&mut arr3);
-        assert!(is_sorted(&arr3));
+        assert!(is_sorted(&arr3) && have_same_elements(&arr3, &cloned));
     }
 }