use gix_diff::{    Rewrites,    index::Change,    rewrites::{Copies, CopySource},};use gix_object::bstr::BStr; #[test]fn empty_to_new_tree_without_rename_tracking() -> crate::Result {    let changes = collect_changes_no_renames(None, "c1 - initial").expect("really just an addition - nothing to track");    insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"    [        Addition {            location: "a",            index: 0,            entry_mode: Mode(                FILE,            ),            id: Oid(1),        },        Addition {            location: "b",            index: 1,            entry_mode: Mode(                FILE,            ),            id: Oid(1),        },        Addition {            location: "d",            index: 2,            entry_mode: Mode(                FILE,            ),            id: Oid(1),        },        Addition {            location: "dir/c",            index: 3,            entry_mode: Mode(                FILE,            ),            id: Oid(1),        },    ]    "#);     {        let (lhs, rhs, _cache, _odb, mut pathspec) = repo_with_indices(None, "c1 - initial", None)?;        let err = gix_diff::index(            &lhs,            &rhs,            |_change| Err(std::io::Error::other("custom error")),            None::<gix_diff::index::RewriteOptions<'_, gix_odb::Handle>>,            &mut pathspec,            &mut |_, _, _, _| true,        )        .unwrap_err();        assert_eq!(            format!("{err:?}"),            r#"Callback(Custom { kind: Other, error: "custom error" })"#,            "custom errors made visible and not squelched"        );    }    Ok(())} #[test]fn changes_against_modified_tree_with_filename_tracking() -> crate::Result {    let changes = collect_changes_no_renames("c2", "c3-modification")?;    insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"    [        Modification {            location: "a",            previous_index: 0,            previous_entry_mode: Mode(                FILE,            ),            previous_id: Oid(1),            index: 0,            entry_mode: Mode(                FILE,            ),            id: Oid(2),        },        Modification {            location: "dir/c",            previous_index: 3,            previous_entry_mode: Mode(                FILE,            ),            previous_id: Oid(3),            index: 3,            entry_mode: Mode(                FILE,            ),            id: Oid(4),        },    ]    "#);    Ok(())} #[test]fn renames_by_identity() -> crate::Result {    for (from, to, expected, assert_msg, track_empty) in [        (            "c3-modification",            "r1-identity",            vec![BStr::new("a"), "dir/a-moved".into()],            "one rename and nothing else",            false,        ),        (            "c4 - add identical files",            "r2-ambiguous",            vec![                "s1".into(),                "b1".into(),                "s2".into(),                "b2".into(),                "s3".into(),                "z".into(),            ],            "multiple possible sources decide by ordering everything lexicographically",            true,        ),        (            "c4 - add identical files",            "r2-ambiguous",            vec![],            "nothing is tracked with `track_empty = false`",            false,        ),        (            "c5 - add links",            "r4-symlinks",            vec!["link-1".into(), "renamed-link-1".into()],            "symlinks are only tracked by identity",            false,        ),        (            "r1-identity",            "c4 - add identical files",            vec![],            "not having any renames is OK as well",            false,        ),        (            "tc1-identity",            "tc1-identity",            vec![],            "copy tracking is off by default",            false,        ),    ] {        for percentage in [None, Some(0.5)] {            let (changes, out) = collect_changes_opts(                from,                to,                Some(Rewrites {                    percentage,                    track_empty,                    ..Default::default()                }),            )?;            let actual: Vec<_> = changes                .into_iter()                .flat_map(|c| match c {                    Change::Rewrite {                        source_location,                        location,                        copy,                        ..                    } => {                        assert!(!copy);                        vec![source_location, location]                    }                    _ => vec![],                })                .collect();             assert_eq!(actual, expected, "{assert_msg}");            #[cfg(not(windows))]            assert_eq!(                out.expect("present as rewrites are configured").num_similarity_checks,                0,                "there are no fuzzy checks in if everything was resolved by identity only"            );        }    }    Ok(())} #[test]fn rename_by_similarity() -> crate::Result {    insta::allow_duplicates! {    for percentage in [        None,        Some(0.76), /*cutoff point where git stops seeing it as equal */    ] {        let (changes, out) = collect_changes_opts(            "r2-ambiguous",            "r3-simple",            Some(Rewrites {                percentage,                ..Default::default()            }),        ).expect("errors can only happen with IO or ODB access fails");            insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"            [                Modification {                    location: "b",                    previous_index: 0,                    previous_entry_mode: Mode(                        FILE,                    ),                    previous_id: Oid(1),                    index: 0,                    entry_mode: Mode(                        FILE,                    ),                    id: Oid(2),                },                Deletion {                    location: "dir/c",                    index: 5,                    entry_mode: Mode(                        FILE,                    ),                    id: Oid(3),                },                Addition {                    location: "dir/c-moved",                    index: 5,                    entry_mode: Mode(                        FILE,                    ),                    id: Oid(4),                },            ]            "#);            let out = out.expect("tracking enabled");            assert_eq!(out.num_similarity_checks, if percentage.is_some() { 1 } else { 0 });            assert_eq!(out.num_similarity_checks_skipped_for_rename_tracking_due_to_limit, 0);            assert_eq!(out.num_similarity_checks_skipped_for_copy_tracking_due_to_limit, 0);        }    }     let (changes, out) = collect_changes_opts(        "r2-ambiguous",        "r3-simple",        Some(Rewrites {            percentage: Some(0.6),            limit: 1, // has no effect as it's just one item here.            ..Default::default()        }),    )    .expect("it found all items at the cut-off point, similar to git");     insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"    [        Modification {            location: "b",            previous_index: 0,            previous_entry_mode: Mode(                FILE,            ),            previous_id: Oid(1),            index: 0,            entry_mode: Mode(                FILE,            ),            id: Oid(2),        },        Rewrite {            source_location: "dir/c",            source_index: 5,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(3),            location: "dir/c-moved",            index: 5,            entry_mode: Mode(                FILE,            ),            id: Oid(4),            copy: false,        },    ]    "#);     let out = out.expect("tracking enabled");    assert_eq!(out.num_similarity_checks, 1);    assert_eq!(out.num_similarity_checks_skipped_for_rename_tracking_due_to_limit, 0);    assert_eq!(out.num_similarity_checks_skipped_for_copy_tracking_due_to_limit, 0);    Ok(())} #[test]fn renames_by_similarity_with_limit() -> crate::Result {    let (changes, out) = collect_changes_opts(        "c6",        "r5",        Some(Rewrites {            limit: 1, // prevent fuzzy tracking from happening            ..Default::default()        }),    )?;    assert_eq!(        changes.iter().filter(|c| matches!(c, Change::Rewrite { .. })).count(),        0,        "fuzzy tracking is effectively disabled due to limit"    );     use gix_diff::index::ChangeRef;     let actual_locations: Vec<_> = changes.iter().map(ChangeRef::location).collect();    assert_eq!(actual_locations, ["f1", "f1-renamed", "f2", "f2-renamed"]);     let actual_indices: Vec<_> = changes.iter().map(ChangeRef::index).collect();    assert_eq!(actual_indices, [6, 6, 7, 7]);     use gix_index::entry::Mode;     let actual_entry_modes: Vec<_> = changes.iter().map(ChangeRef::entry_mode).collect();    assert_eq!(actual_entry_modes, [Mode::FILE, Mode::FILE, Mode::FILE, Mode::FILE]);     let actual_ids: Vec<_> = changes.iter().map(ChangeRef::id).collect();    let expected_ids = [        crate::hex_to_id(            "f00c965d8307308469e537302baa73048488f162",            "300fc9db3fb50e3794eb4013cfe2c9f6c0fa1d8db7f9e3a4f6f0158b3b62cc69",        ),        crate::hex_to_id(            "683cfcc0f47566c332aa45d81c5cc98acb4aab49",            "b863f94555dd058a680cca6d4afa1bad30b5f9c36122c7089f853081aa1c5a28",        ),        crate::hex_to_id(            "3bb459b831ea471b9cd1cbb7c6d54a74251a711b",            "19ebb6b2c2f3a64e6578013f680ec39330ce158af5977a1b17be0d551185fbab",        ),        crate::hex_to_id(            "0a805f8e02d72bd354c1f00607906de2e49e00d6",            "6271a9ad76b692e75a96d260cf02c4cd89e1d2071256447ff50e8a8f443299b4",        ),    ];    assert_eq!(actual_ids, expected_ids);     let out = out.expect("tracking enabled");    assert_eq!(out.num_similarity_checks, 0);    assert_eq!(out.num_similarity_checks_skipped_for_rename_tracking_due_to_limit, 4);    assert_eq!(out.num_similarity_checks_skipped_for_copy_tracking_due_to_limit, 0);     Ok(())} #[test]fn copies_by_identity() -> crate::Result {    let (changes, out) = collect_changes_opts(        "c7",        "tc1-identity",        Some(Rewrites {            copies: Some(Copies {                source: CopySource::FromSetOfModifiedFiles,                percentage: None,            }),            limit: 1, // the limit isn't actually used for identity based checks            ..Default::default()        }),    )?;    insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"    [        Rewrite {            source_location: "base",            source_index: 3,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(1),            location: "c1",            index: 4,            entry_mode: Mode(                FILE,            ),            id: Oid(1),            copy: true,        },        Rewrite {            source_location: "base",            source_index: 3,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(1),            location: "c2",            index: 5,            entry_mode: Mode(                FILE,            ),            id: Oid(1),            copy: true,        },        Rewrite {            source_location: "base",            source_index: 3,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(1),            location: "dir/c3",            index: 9,            entry_mode: Mode(                FILE,            ),            id: Oid(1),            copy: true,        },    ]    "#);    let out = out.expect("tracking enabled");    assert_eq!(out.num_similarity_checks, 0);    assert_eq!(out.num_similarity_checks_skipped_for_rename_tracking_due_to_limit, 0);    assert_eq!(out.num_similarity_checks_skipped_for_copy_tracking_due_to_limit, 0);     Ok(())} #[test]fn copies_by_similarity() -> crate::Result {    let (changes, out) = collect_changes_opts(        "tc1-identity",        "tc2-similarity",        Some(Rewrites {            copies: Some(Copies::default()),            ..Default::default()        }),    )?;    insta::assert_snapshot!(crate::normalize_debug_snapshot(&changes).0, @r#"    [        Rewrite {            source_location: "base",            source_index: 3,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(1),            location: "c4",            index: 6,            entry_mode: Mode(                FILE,            ),            id: Oid(1),            copy: true,        },        Rewrite {            source_location: "base",            source_index: 3,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(1),            location: "c5",            index: 7,            entry_mode: Mode(                FILE,            ),            id: Oid(2),            copy: true,        },        Rewrite {            source_location: "base",            source_index: 3,            source_entry_mode: Mode(                FILE,            ),            source_id: Oid(1),            location: "dir/c6",            index: 12,            entry_mode: Mode(                FILE,            ),            id: Oid(3),            copy: true,        },    ]    "#);     let out = out.expect("tracking enabled");    assert_eq!(        out.num_similarity_checks, 2,        "two are similar, the other one is identical"    );    assert_eq!(out.num_similarity_checks_skipped_for_rename_tracking_due_to_limit, 0);    assert_eq!(out.num_similarity_checks_skipped_for_copy_tracking_due_to_limit, 0);     Ok(())} 

Lines 1–500 of 1413. Load more