Replace all tests with insta tests

src/algorithms/myers.rs

@@ -183,59 +183,34 @@ fn test_diff() {
     let a: &[usize] = &[0, 1, 2, 3, 4];
     let b: &[usize] = &[0, 1, 2, 9, 4];
 
-    struct D;
+    let mut d = crate::algorithms::Replace::new(crate::algorithms::CaptureHook::new());
-    impl DiffHook for D {
+    diff_slices(&mut d, a, b).unwrap();
-        type Error = ();
+    insta::assert_debug_snapshot!(d.into_inner().ops(), @r###"
-        fn delete(&mut self, o: usize, len: usize, new: usize) -> Result<(), ()> {
+    [
-            assert_eq!(o, 3);
+        Equal {
-            assert_eq!(len, 1);
+            old_index: 0,
-            assert_eq!(new, 3);
+            new_index: 0,
-            println!("delete");
+            len: 3,
-            Ok(())
+        },
-        }
+        Replace {
-        fn insert(&mut self, o: usize, n: usize, len: usize) -> Result<(), ()> {
+            old_index: 3,
-            assert_eq!(o, 3);
+            old_len: 1,
-            assert_eq!(n, 3);
+            new_index: 3,
-            assert_eq!(len, 1);
+            new_len: 1,
-            println!("insert");
+        },
-            Ok(())
+        Equal {
-        }
+            old_index: 4,
-    }
+            new_index: 4,
-
+            len: 1,
-    let mut d = crate::algorithms::Replace::new(D);
+        },
-    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap()
+    ]
+    "###);
 }
 
 #[test]
 fn test_contiguous() {
     let a: &[usize] = &[0, 1, 2, 3, 4, 4, 4, 5];
     let b: &[usize] = &[0, 1, 2, 8, 9, 4, 4, 7];
-    struct D;
-
-    impl DiffHook for D {
-        type Error = ();
-        fn delete(&mut self, _o: usize, _len: usize, _new: usize) -> Result<(), ()> {
-            panic!("Should not delete")
-        }
-        fn insert(&mut self, _o: usize, _n: usize, _len: usize) -> Result<(), ()> {
-            panic!("Should not insert")
-        }
-        fn replace(&mut self, o: usize, l: usize, n: usize, nl: usize) -> Result<(), ()> {
-            assert!(o != 3 || (l == 2 && nl == 2));
-            assert!(o != 7 || (l == 1 && nl == 1));
-            println!("replace {:?} {:?} {:?} {:?}", o, l, n, nl);
-            Ok(())
-        }
-    }
-
-    let mut d = crate::algorithms::Replace::new(D);
-    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap();
-}
-
-#[test]
-fn test_replace() {
-    let a: &[usize] = &[0, 1, 2, 3, 4];
-    let b: &[usize] = &[0, 1, 2, 7, 8, 9];
 
     let mut d = crate::algorithms::Replace::new(crate::algorithms::CaptureHook::new());
     diff_slices(&mut d, a, b).unwrap();
@@ -250,7 +225,18 @@ fn test_replace() {
             old_index: 3,
             old_len: 2,
             new_index: 3,
-            new_len: 3,
+            new_len: 2,
+        },
+        Equal {
+            old_index: 5,
+            new_index: 5,
+            len: 2,
+        },
+        Replace {
+            old_index: 7,
+            old_len: 1,
+            new_index: 7,
+            new_len: 1,
         },
     ]
     "###);

src/algorithms/patience.rs

@@ -180,52 +180,50 @@ fn test_patience() {
     let a: &[usize] = &[11, 1, 2, 2, 3, 4, 4, 4, 5, 47, 19];
     let b: &[usize] = &[10, 1, 2, 2, 8, 9, 4, 4, 7, 47, 18];
 
-    struct D(Vec<(usize, usize, usize, usize)>);
+    let mut d = Replace::new(crate::algorithms::CaptureHook::new());
-    impl DiffHook for D {
+    diff_slices(&mut d, a, b).unwrap();
-        type Error = ();
-        fn delete(&mut self, o: usize, len: usize, new: usize) -> Result<(), ()> {
-            self.0.push((o, len, new, 0));
-            Ok(())
-        }
-        fn insert(&mut self, o: usize, n: usize, len: usize) -> Result<(), ()> {
-            self.0.push((o, 0, n, len));
-            Ok(())
-        }
-        fn replace(&mut self, o: usize, l: usize, n: usize, nl: usize) -> Result<(), ()> {
-            self.0.push((o, l, n, nl));
-            Ok(())
-        }
-    }
-    let mut d = Replace::new(D(Vec::new()));
-    diff(&mut d, a, 0..a.len(), b, 0..b.len()).unwrap();
-    let d: D = d.into_inner();
 
-    insta::assert_json_snapshot!(&d.0.as_slice(), @r###"
+    insta::assert_debug_snapshot!(d.into_inner().ops(), @r###"
     [
-      [
+        Replace {
-        0,
+            old_index: 0,
-        1,
+            old_len: 1,
-        0,
+            new_index: 0,
-        1
+            new_len: 1,
-      ],
+        },
-      [
+        Equal {
-        4,
+            old_index: 1,
-        2,
+            new_index: 1,
-        4,
+            len: 3,
-        2
+        },
-      ],
+        Replace {
-      [
+            old_index: 4,
-        8,
+            old_len: 2,
-        1,
+            new_index: 4,
-        8,
+            new_len: 2,
-        1
+        },
-      ],
+        Equal {
-      [
+            old_index: 6,
-        10,
+            new_index: 6,
-        1,
+            len: 2,
-        10,
+        },
-        1
+        Replace {
-      ]
+            old_index: 8,
+            old_len: 1,
+            new_index: 8,
+            new_len: 1,
+        },
+        Equal {
+            old_index: 9,
+            new_index: 9,
+            len: 1,
+        },
+        Replace {
+            old_index: 10,
+            old_len: 1,
+            new_index: 10,
+            new_len: 1,
+        },
     ]
     "###);
 }