Allow generic bubble sorting + parameterised tests

sorting/Cargo.toml

@@ -7,3 +7,6 @@ edition = "2021"
 
 [dependencies]
 rand = "0.8.4"
+
+[dev-dependencies]
+test-case = "1.2.1"

sorting/src/lib.rs

@@ -1,5 +1,5 @@
 pub mod bubble_sort {
-    pub fn sort(vec: &mut Vec<usize>) {
+    pub fn sort<T: PartialOrd + Copy>(vec: &mut Vec<T>) {
         for outer in (0..vec.len()).rev() {
             for inner in 0..outer {
                 if vec[inner] > vec[inner + 1] {
@@ -10,7 +10,7 @@ pub mod bubble_sort {
     }
 }
 
-fn swap(vec: &mut Vec<usize>, index_one: usize, index_two: usize) {
+fn swap<T: PartialOrd + Copy>(vec: &mut Vec<T>, index_one: usize, index_two: usize) {
     let temp = vec[index_two];
     vec[index_two] = vec[index_one];
     vec[index_one] = temp;
@@ -19,17 +19,17 @@ fn swap(vec: &mut Vec<usize>, index_one: usize, index_two: usize) {
 #[cfg(test)]
 mod lib_tests {
     use super::*;
+    use std::fmt::Debug;
+    use test_case::test_case;
 
-    #[test]
+    #[test_case(vec ! [1, 2], vec ! [2, 1]; "integers")]
-    fn can_swap_numbers() {
+    #[test_case(vec ! ["hello", "world"], vec ! ["world", "hello"]; "strings")]
-        // Arrange
+    #[test_case(vec ! [5.0, 10.0], vec ! [10.0, 5.0]; "floats")]
-        let mut vec = vec![1, 2];
+    fn can_swap<T: PartialOrd + Copy + Debug>(mut actual: Vec<T>, expected: Vec<T>) {
-
         // Act
-        swap(&mut vec, 0, 1);
+        swap(&mut actual, 0, 1);
 
         // Assert
-        assert_eq!(vec[0], 2);
+        assert_eq!(actual, expected);
-        assert_eq!(vec[1], 1);
     }
 }

sorting/tests/integration_tests.rs

@@ -1,18 +1,22 @@
-use rand::seq::SliceRandom;
+use std::fmt::Debug;
+use rand::{
+    seq::SliceRandom,
+    thread_rng
+};
 use sorting;
-use rand::thread_rng;
+use test_case::test_case;
+use sorting::bubble_sort::sort;
 
-#[test]
+#[test_case((0..20).rev().collect(), (0..20).collect() ; "integers")]
-fn bubble_sort_ascending() {
+#[test_case(vec!["c", "b", "a"], vec!["a", "b", "c"] ; "strings")]
+#[test_case(vec![6.0, 10.0, 2.0, 4.0, 8.0], vec![2.0, 4.0, 6.0, 8.0, 10.0] ; "floats")]
+fn can_bubble_sort<T: PartialOrd + Copy + Debug>(mut actual: Vec<T>, expected: Vec<T>) {
     // Arrange
-    let mut vec: Vec<usize> = (0..20).rev().collect();
+    actual.shuffle(&mut thread_rng());
-    vec.shuffle(&mut thread_rng());
 
     // Act
-    sorting::bubble_sort::sort(&mut vec);
+    sort(&mut actual);
 
     // Assert
-    for i in 0..20 {
+    assert_eq!(actual, expected);
-        assert_eq!(vec[i], i);
-    }
 }