use crate::fixture_index_path;use crate::index::file::read::loose_file_path;use filetime::FileTime;use git_index::verify::extensions::no_find;use git_index::write::Options;use git_index::{decode, entry, extension, write, State, Version}; /// Round-trips should eventually be possible for all files we have, as we write them back exactly as they were read.#[test]fn roundtrips() -> crate::Result {    enum Kind {        Generated(&'static str),        Loose(&'static str),    }    use Kind::*;    let input = [        (Loose("extended-flags"), all_ext_but_eoie()),        (Loose("conflicting-file"), all_ext_but_eoie()),        (Loose("very-long-path"), all_ext_but_eoie()),        (Generated("v2"), Options::default()),        (Generated("V2_empty"), Options::default()),        (Generated("v2_more_files"), all_ext_but_eoie()),    ];     for (fixture, options) in input {        let (path, fixture) = match fixture {            Generated(name) => (fixture_index_path(name), name),            Loose(name) => (loose_file_path(name), name),        };        let expected = git_index::File::at(&path, decode::Options::default())?;        let expected_bytes = std::fs::read(&path)?;        let mut out_bytes = Vec::new();         let actual_version = expected.write_to(&mut out_bytes, options)?;        assert_eq!(            actual_version,            expected.version(),            "{} didn't write the expected version",            fixture        );        let (actual, _) = State::from_bytes(&out_bytes, FileTime::now(), decode::Options::default())?;         compare_states(&actual, actual_version, &expected, options, fixture);        compare_raw_bytes(&out_bytes, &expected_bytes, fixture);    }    Ok(())} #[test]fn state_comparisons_with_various_extension_configurations() {    fn options_with(extensions: write::Extensions) -> Options {        Options {            hash_kind: git_hash::Kind::Sha1,            extensions,        }    }     enum Kind {        Generated(&'static str),        Loose(&'static str),    }    use Kind::*;     for fixture in [        Loose("extended-flags"),        Loose("conflicting-file"),        Loose("very-long-path"),        Loose("FSMN"),        Loose("REUC"),        Loose("UNTR-with-oids"),        Loose("UNTR"),        Generated("V2_empty"),        Generated("v2"),        Generated("v2_more_files"),        Generated("v2_split_index"),        Generated("v4_more_files_IEOT"),    ] {        for options in [            options_with(write::Extensions::None),            options_with(write::Extensions::All),            options_with(write::Extensions::Given {                tree_cache: true,                end_of_index_entry: true,            }),            options_with(write::Extensions::Given {                tree_cache: false,                end_of_index_entry: true,            }),        ] {            let (path, fixture) = match fixture {                Generated(name) => (fixture_index_path(name), name),                Loose(name) => (loose_file_path(name), name),            };            let expected = git_index::File::at(&path, Default::default()).unwrap();             let mut out = Vec::<u8>::new();            let actual_version = expected.write_to(&mut out, options).unwrap();             let (actual, _) = State::from_bytes(&out, FileTime::now(), decode::Options::default()).unwrap();            compare_states(&actual, actual_version, &expected, options, fixture);        }    }} #[test]fn extended_flags_automatically_upgrade_the_version_to_avoid_data_loss() -> crate::Result {    let mut expected = git_index::File::at(fixture_index_path("v2"), Default::default())?;    assert_eq!(expected.version(), Version::V2);    expected.entries_mut()[0].flags.insert(entry::Flags::EXTENDED);     let mut buf = Vec::new();    let actual_version = expected.write_to(&mut buf, Default::default())?;    assert_eq!(actual_version, Version::V3, "extended flags need V3");     Ok(())} fn compare_states(actual: &State, actual_version: Version, expected: &State, options: Options, fixture: &str) {    actual.verify_entries().expect("valid");    actual.verify_extensions(false, no_find).expect("valid");     assert_eq!(actual.version(), actual_version, "version mismatch in {}", fixture);    assert_eq!(        actual.tree(),        options            .extensions            .should_write(extension::tree::SIGNATURE)            .and_then(|_| expected.tree()),        "tree extension mismatch in {}",        fixture    );    assert_eq!(        actual.entries().len(),        expected.entries().len(),        "entry count mismatch in {}",        fixture    );    assert_eq!(actual.entries(), expected.entries(), "entries mismatch in {}", fixture);    assert_eq!(        actual.path_backing(),        expected.path_backing(),        "path_backing mismatch in {}",        fixture    );} fn compare_raw_bytes(generated: &[u8], expected: &[u8], fixture: &str) {    assert_eq!(generated.len(), expected.len(), "file length mismatch in {}", fixture);     let print_range = 10;    for (index, (a, b)) in generated.iter().zip(expected.iter()).enumerate() {        if a != b {            let range_left = index.saturating_sub(print_range);            let range_right = (index + print_range).min(generated.len());            let generated = &generated[range_left..range_right];            let expected = &expected[range_left..range_right];             panic! {"\n\nRoundtrip failed for index in fixture {:?} at position {:?}\n\            \t  Actual: ... {:?} ...\n\            \tExpected: ... {:?} ...\n\n\            ", &fixture, index, generated, expected}        }    }} fn all_ext_but_eoie() -> Options {    Options {        extensions: write::Extensions::Given {            end_of_index_entry: false,            tree_cache: true,        },        ..Options::default()    }}