Refactor rstests as tests

Cargo.toml

@@ -39,7 +39,6 @@ unicode-width = "0.2"
 [dev-dependencies]
 gethostname = "0.4.0"
 pretty_assertions = "1.4.0"
-rstest = { version = "0.23.0", default-features = false }
 serde_json = "1.0"
 tempfile = "3.3.0"
 

src/completion/history.rs

@@ -72,8 +72,6 @@ impl<'menu> HistoryCompleter<'menu> {
 
 #[cfg(test)]
 mod tests {
-    use rstest::rstest;
-
     use super::*;
     use crate::*;
 
@@ -134,26 +132,32 @@ mod tests {
         Ok(())
     }
 
-    #[rstest]
-    #[case(vec![], "any", vec![])]
-    #[case(vec!["old match","recent match","between","recent match"], "match", vec!["recent match","old match"])]
-    #[case(vec!["a","b","c","a","b","c"], "", vec!["c","b","a"])]
-    fn complete_doesnt_return_duplicates(
-        #[case] history_items: Vec<&str>,
-        #[case] line: &str,
-        #[case] expected: Vec<&str>,
-    ) -> Result<()> {
-        let mut history = FileBackedHistory::new(history_items.len())?;
-        for history_item in history_items {
-            history.save(new_history_item(history_item))?;
+    #[test]
+    fn complete_doesnt_return_duplicates() -> Result<()> {
+        let cases = [
+            (vec![], "any", vec![]),
+            (
+                vec!["old match", "recent match", "between", "recent match"],
+                "match",
+                vec!["recent match", "old match"],
+            ),
+            (vec!["a", "b", "c", "a", "b", "c"], "", vec!["c", "b", "a"]),
+        ];
+
+        for (history_items, line, expected) in cases {
+            let mut history = FileBackedHistory::new(history_items.len())?;
+            for history_item in history_items {
+                history.save(new_history_item(history_item))?;
+            }
+            let mut sut = HistoryCompleter::new(&history);
+            let actual: Vec<String> = sut
+                .complete(line, line.len())
+                .into_iter()
+                .map(|suggestion| suggestion.value)
+                .collect();
+            assert_eq!(actual, expected);
         }
-        let mut sut = HistoryCompleter::new(&history);
-        let actual: Vec<String> = sut
-            .complete(line, line.len())
-            .into_iter()
-            .map(|suggestion| suggestion.value)
-            .collect();
-        assert_eq!(actual, expected);
+
         Ok(())
     }
 }

src/core_editor/edit_stack.rs

@@ -65,7 +65,6 @@ where
 mod test {
     use super::*;
     use pretty_assertions::assert_eq;
-    use rstest::rstest;
 
     fn edit_stack<T>(values: &[T], index: usize) -> EditStack<T>
     where
@@ -77,37 +76,52 @@ mod test {
         }
     }
 
-    #[rstest]
-    #[case(edit_stack(&[1, 2, 3][..], 2), 2)]
-    #[case(edit_stack(&[1][..], 0), 1)]
-    fn undo_works(#[case] stack: EditStack<isize>, #[case] value_after_undo: isize) {
-        let mut stack = stack;
+    #[test]
+    fn undo_works() {
+        let cases = [
+            (edit_stack(&[1, 2, 3][..], 2), 2),
+            (edit_stack(&[1][..], 0), 1),
+        ];
 
-        let value = stack.undo();
-        assert_eq!(*value, value_after_undo);
+        for (stack, value_after_undo) in cases {
+            let mut stack = stack;
+
+            let value = stack.undo();
+            assert_eq!(*value, value_after_undo);
+        }
     }
 
-    #[rstest]
-    #[case(edit_stack(&[1, 2, 3][..], 1), 3)]
-    #[case(edit_stack(&[1][..], 0), 1)]
-    fn redo_works(#[case] stack: EditStack<isize>, #[case] value_after_undo: isize) {
-        let mut stack = stack;
+    #[test]
+    fn redo_works() {
+        let cases = [
+            (edit_stack(&[1, 2, 3][..], 1), 3),
+            (edit_stack(&[1][..], 0), 1),
+        ];
 
-        let value = stack.redo();
-        assert_eq!(*value, value_after_undo);
+        for (stack, value_after_undo) in cases {
+            let mut stack = stack;
+
+            let value = stack.redo();
+            assert_eq!(*value, value_after_undo);
+        }
     }
 
-    #[rstest]
-    #[case(edit_stack(&[1, 2, 3][..], 1), 4, edit_stack(&[1, 2, 4], 2))]
-    #[case(edit_stack(&[1, 2, 3][..], 2), 3, edit_stack(&[1, 2, 3, 3], 3))]
-    fn insert_works(
-        #[case] old_stack: EditStack<isize>,
-        #[case] value_to_insert: isize,
-        #[case] expected_stack: EditStack<isize>,
-    ) {
-        let mut stack = old_stack;
-
-        stack.insert(value_to_insert);
-        assert_eq!(stack, expected_stack);
+    #[test]
+    fn insert_works() {
+        let cases = [
+            (edit_stack(&[1, 2, 3][..], 1), 4, edit_stack(&[1, 2, 4], 2)),
+            (
+                edit_stack(&[1, 2, 3][..], 2),
+                3,
+                edit_stack(&[1, 2, 3, 3], 3),
+            ),
+        ];
+
+        for (old_stack, value_to_insert, expected_stack) in cases {
+            let mut stack = old_stack;
+
+            stack.insert(value_to_insert);
+            assert_eq!(stack, expected_stack);
+        }
     }
 }