Update to imara-diff 0.2 in diff slider test

gix-diff/tests/diff/blob/slider.rs

@@ -1,11 +1,11 @@
-use gix_diff::blob::intern::TokenSource;
-use gix_diff::blob::unified_diff::ContextSize;
-use gix_diff::blob::{Algorithm, UnifiedDiff};
+use gix_object::bstr::ByteSlice;
 use gix_testtools::bstr::{BString, ByteVec};
 use pretty_assertions::StrComparison;
 
 #[test]
-fn baseline() -> gix_testtools::Result {
+fn baseline_v1() -> gix_testtools::Result {
+    use gix_diff::blob::{unified_diff::ContextSize, Algorithm, UnifiedDiff};
+
     let worktree_path = gix_testtools::scripted_fixture_read_only_standalone("make_diff_for_sliders_repo.sh")?;
     let asset_dir = worktree_path.join("assets");
 
@@ -119,10 +119,113 @@ fn baseline() -> gix_testtools::Result {
     Ok(())
 }
 
-fn tokens_for_diffing(data: &[u8]) -> impl TokenSource<Token = &[u8]> {
+fn tokens_for_diffing(data: &[u8]) -> impl gix_diff::blob::intern::TokenSource<Token = &[u8]> {
     gix_diff::blob::sources::byte_lines(data)
 }
 
+#[test]
+fn baseline_v2() -> gix_testtools::Result {
+    use gix_diff::blob::v2::{Algorithm, BasicLineDiffPrinter, Diff, InternedInput, UnifiedDiffConfig};
+
+    let worktree_path = gix_testtools::scripted_fixture_read_only_standalone("make_diff_for_sliders_repo.sh")?;
+    let asset_dir = worktree_path.join("assets");
+
+    let dir = std::fs::read_dir(&worktree_path)?;
+
+    let mut diffs = Vec::new();
+
+    for entry in dir {
+        let entry = entry?;
+        let file_name = entry.file_name().into_string().expect("to be string");
+
+        if !file_name.ends_with(".baseline") {
+            continue;
+        }
+
+        let parts: Vec<_> = file_name.split('.').collect();
+        let [name, algorithm, ..] = parts[..] else {
+            unreachable!()
+        };
+        let algorithm = match algorithm {
+            "myers" => Algorithm::Myers,
+            "histogram" => Algorithm::Histogram,
+            _ => unreachable!(),
+        };
+
+        let parts: Vec<_> = name.split('-').collect();
+        let [old_blob_id, new_blob_id] = parts[..] else {
+            unreachable!();
+        };
+
+        let old_data = std::fs::read(asset_dir.join(format!("{old_blob_id}.blob")))?;
+        let new_data = std::fs::read(asset_dir.join(format!("{new_blob_id}.blob")))?;
+
+        let input = InternedInput::new(old_data.to_str().unwrap(), new_data.to_str().unwrap());
+
+        let mut diff = Diff::compute(algorithm, &input);
+        diff.postprocess_lines(&input);
+
+        let actual = diff
+            .unified_diff(
+                &BasicLineDiffPrinter(&input.interner),
+                UnifiedDiffConfig::default(),
+                &input,
+            )
+            .to_string();
+
+        let baseline_path = worktree_path.join(&file_name);
+        let baseline = std::fs::read(baseline_path)?;
+        let baseline = baseline::Baseline::new(&baseline);
+
+        let baseline = baseline
+            .fold(BString::default(), |mut acc, diff_hunk| {
+                acc.push_str(diff_hunk.header.to_string().as_str());
+                acc.push(b'\n');
+
+                acc.extend_from_slice(&diff_hunk.lines);
+
+                acc
+            })
+            .to_string();
+
+        let actual_matches_baseline = actual == baseline;
+        diffs.push((actual, baseline, actual_matches_baseline, file_name));
+    }
+
+    if diffs.is_empty() {
+        eprintln!("Slider baseline isn't setup - look at ./gix-diff/tests/README.md for instructions");
+    }
+
+    let total_diffs = diffs.len();
+    let matching_diffs = diffs
+        .iter()
+        .filter(|(_, _, actual_matches_baseline, _)| *actual_matches_baseline)
+        .count();
+
+    assert_eq!(
+        matching_diffs,
+        total_diffs,
+        "matching diffs {} == total diffs {} [{:.2} %]\n\n{}",
+        matching_diffs,
+        total_diffs,
+        ((matching_diffs as f32) / (total_diffs as f32) * 100.0),
+        {
+            let first_non_matching_diff = diffs
+                .iter()
+                .find(|(_, _, actual_matches_baseline, _)| !actual_matches_baseline)
+                .expect("at least one non-matching diff to be there");
+
+            format!(
+                "affected baseline: `{}`\n\n{}",
+                first_non_matching_diff.3,
+                StrComparison::new(&first_non_matching_diff.0, &first_non_matching_diff.1)
+            )
+        }
+    );
+
+    Ok(())
+}
+
 mod baseline {
     use gix_object::bstr::ByteSlice;
     use std::iter::Peekable;