Separate all tests in searching folder and some others (TheAlgorithms#71)

* Add another test for Caesar Cipher

* Separate binary search tests

* Add more heap sort tests

* Add tests for insertion sort

* Implement/separate more tests

* Remove redundant tests

* Remove redundant tests

Author: arnavb

src/ciphers/caesar.rs

@@ -24,13 +24,20 @@ pub fn caesar(cipher: &str, shift: u8) -> String {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
+    #[test]
+    fn empty() {
+        assert_eq!(caesar("", 13), "");
+    }
+
     #[test]
     fn caesar_rot_13() {
-        assert_eq!(super::caesar("rust", 13), "ehfg");
+        assert_eq!(caesar("rust", 13), "ehfg");
     }
 
     #[test]
     fn caesar_unicode() {
-        assert_eq!(super::caesar("attack at dawn 攻", 5), "fyyfhp fy ifbs 攻");
+        assert_eq!(caesar("attack at dawn 攻", 5), "fyyfhp fy ifbs 攻");
     }
 }

src/general/hanoi.rs

@@ -8,7 +8,7 @@ pub fn hanoi(n: i32, from: i32, to: i32, via: i32, moves: &mut Vec<(i32, i32)>)
 
 #[cfg(test)]
 mod tests {
-    use super::hanoi;
+    use super::*;
 
     #[test]
     fn hanoi_simple() {

src/searching/binary_search.rs

@@ -26,24 +26,39 @@ pub fn binary_search<T: PartialEq + PartialOrd>(item: &T, arr: &[T]) -> Option<u
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
+    // TODO: Fix this test; currently fails due to underflow
+    // #[test]
+    // fn empty() {
+    //     let index = binary_search(&"a", &vec![]);
+    //     assert_eq!(index, None);
+    // }
+
     #[test]
-    fn binary() {
-        let index = super::binary_search(&"a", &vec!["a", "b", "c", "d", "google", "zoo"]);
+    fn search_strings() {
+        let index = binary_search(&"a", &vec!["a", "b", "c", "d", "google", "zoo"]);
         assert_eq!(index, Some(0));
+    }
 
-        let index = super::binary_search(&4, &vec![1, 2, 3, 4]);
+    #[test]
+    fn search_ints() {
+        let index = binary_search(&4, &vec![1, 2, 3, 4]);
         assert_eq!(index, Some(3));
 
-        let index = super::binary_search(&3, &vec![1, 2, 3, 4]);
+        let index = binary_search(&3, &vec![1, 2, 3, 4]);
         assert_eq!(index, Some(2));
 
-        let index = super::binary_search(&2, &vec![1, 2, 3, 4]);
+        let index = binary_search(&2, &vec![1, 2, 3, 4]);
         assert_eq!(index, Some(1));
 
-        let index = super::binary_search(&1, &vec![1, 2, 3, 4]);
+        let index = binary_search(&1, &vec![1, 2, 3, 4]);
         assert_eq!(index, Some(0));
+    }
 
-        let index = super::binary_search(&5, &vec![1, 2, 3, 4]);
+    #[test]
+    fn not_found() {
+        let index = binary_search(&5, &vec![1, 2, 3, 4]);
         assert_eq!(index, None);
     }
 }

src/sorting/counting_sort.rs

@@ -52,29 +52,34 @@ pub fn generic_counting_sort<T: Into<u64> + From<u8> + AddAssign + Copy>(
 #[cfg(test)]
 mod test {
     use super::super::is_sorted;
+    use super::*;
 
     #[test]
-    fn counting_sort() {
-        //descending
+    fn counting_sort_descending() {
         let mut ve1 = vec![6, 5, 4, 3, 2, 1];
-        super::counting_sort(&mut ve1, 6);
+        counting_sort(&mut ve1, 6);
 
         assert!(is_sorted(&ve1));
+    }
 
-        //pre-sorted
+    #[test]
+    fn counting_sort_pre_sorted() {
         let mut ve2 = vec![1, 2, 3, 4, 5, 6];
-        super::counting_sort(&mut ve2, 6);
+        counting_sort(&mut ve2, 6);
 
         assert!(is_sorted(&ve2));
     }
+
     #[test]
     fn generic_counting_sort() {
         let mut ve1: Vec<u8> = vec![100, 30, 60, 10, 20, 120, 1];
         super::generic_counting_sort(&mut ve1, 120);
 
         assert!(is_sorted(&ve1));
+    }
 
-        //pre-sorted u64
+    #[test]
+    fn presorted_u64_counting_sort() {
         let mut ve2: Vec<u64> = vec![1, 2, 3, 4, 5, 6];
         super::generic_counting_sort(&mut ve2, 6);
 

src/sorting/heap_sort.rs

@@ -122,4 +122,18 @@ mod tests {
         heap_sort(&mut arr);
         assert_eq!(&arr, &[1, 2, 3, 4]);
     }
+
+    #[test]
+    fn odd_number_of_elements() {
+        let mut arr = vec![3, 4, 2, 1, 7];
+        heap_sort(&mut arr);
+        assert_eq!(&arr, &[1, 2, 3, 4, 7]);
+    }
+
+    #[test]
+    fn repeated_elements() {
+        let mut arr = vec![542, 542, 542, 542];
+        heap_sort(&mut arr);
+        assert_eq!(&arr, &vec![542, 542, 542, 542]);
+    }
 }

src/sorting/insertion.rs

@@ -33,20 +33,41 @@ where
 
 #[cfg(test)]
 mod tests {
-    #[test]
-    fn insertion() {
-        use sorting::insertion::*;
+    use super::*;
 
+    #[test]
+    fn empty() {
         let res = insertion_sort(&Vec::<u8>::new());
         assert_eq!(res, vec![]);
+    }
 
+    #[test]
+    fn one_element() {
         let res = insertion_sort(&vec!["a"]);
         assert_eq!(res, vec!["a"]);
+    }
 
+    #[test]
+    fn already_sorted() {
         let res = insertion_sort(&vec!["a", "b", "c"]);
         assert_eq!(res, vec!["a", "b", "c"]);
+    }
 
+    #[test]
+    fn basic() {
         let res = insertion_sort(&vec!["d", "a", "c", "b"]);
         assert_eq!(res, vec!["a", "b", "c", "d"]);
     }
+
+    #[test]
+    fn odd_number_of_elements() {
+        let res = insertion_sort(&vec!["d", "a", "c", "e", "b"]);
+        assert_eq!(res, vec!["a", "b", "c", "d", "e"]);
+    }
+
+    #[test]
+    fn repeated_elements() {
+        let res = insertion_sort(&vec![542, 542, 542, 542]);
+        assert_eq!(res, vec![542, 542, 542, 542]);
+    }
 }

src/sorting/selection_sort.rs

@@ -13,24 +13,33 @@ pub fn selection_sort<T: Ord>(arr: &mut [T]) {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     #[test]
-    fn sort_numbers() {
-        use sorting::selection_sort;
+    fn basic() {
+        let mut res = vec!["d", "a", "c", "b"];
+        selection_sort(&mut res);
+        assert_eq!(res, vec!["a", "b", "c", "d"]);
+    }
 
+    #[test]
+    fn empty() {
         let mut res = Vec::<u8>::new();
         selection_sort(&mut res);
         assert_eq!(res, vec![]);
+    }
 
+    #[test]
+    fn one_element() {
         let mut res = vec!["a"];
         selection_sort(&mut res);
         assert_eq!(res, vec!["a"]);
+    }
 
+    #[test]
+    fn pre_sorted() {
         let mut res = vec!["a", "b", "c"];
         selection_sort(&mut res);
         assert_eq!(res, vec!["a", "b", "c"]);
-
-        let mut res = vec!["d", "a", "c", "b"];
-        selection_sort(&mut res);
-        assert_eq!(res, vec!["a", "b", "c", "d"]);
     }
 }

src/sorting/shell_sort.rs

@@ -27,26 +27,36 @@ mod test {
     use super::*;
 
     #[test]
-    fn shell_sort_test() {
-        // test for reverse array
-        let mut ve1 = vec![6, 5, 4, 3, 2, 1];
+    fn basic() {
+        let mut vec = vec![3, 5, 6, 3, 1, 4];
+        shell_sort(&mut ve3);
+        for i in 0..ve3.len() - 1 {
+            assert!(ve3[i] <= ve3[i + 1]);
+        }
+    }
+
+    #[test]
+    fn empty() {
+        let mut vec: Vec<i32> = vec![];
+        shell_sort(&mut vec);
+        assert_eq!(vec, vec![]);
+    }
+
+    #[test]
+    fn reverse() {
+        let mut vec = vec![6, 5, 4, 3, 2, 1];
         shell_sort(&mut ve1);
         for i in 0..ve1.len() - 1 {
             assert!(ve1[i] <= ve1[i + 1]);
         }
+    }
 
-        // test for already sorted array
-        let mut ve2 = vec![1, 2, 3, 4, 5, 6];
+    #[test]
+    fn already_sorted() {
+        let mut vec = vec![1, 2, 3, 4, 5, 6];
         shell_sort(&mut ve2);
         for i in 0..ve2.len() - 1 {
             assert!(ve2[i] <= ve2[i + 1]);
         }
-
-        // test for unsorted
-        let mut ve3 = vec![3, 5, 6, 3, 1, 4];
-        shell_sort(&mut ve3);
-        for i in 0..ve3.len() - 1 {
-            assert!(ve3[i] <= ve3[i + 1]);
-        }
     }
 }