use gix_object::{Tree, TreeRef, TreeRefIter, WriteTo, bstr::ByteSlice, tree, tree::EntryRef}; use crate::{fixture_oid, tree_fixture}; #[test]fn empty() -> crate::Result {    let tree_ref = TreeRef::from_bytes(&[], gix_testtools::object_hash())?;    assert_eq!(        tree_ref,        TreeRef { entries: vec![] },        "empty trees are valid despite usually rare in the wild"    );     let mut buf = Vec::new();    tree_ref.write_to(&mut buf)?;    assert!(buf.is_empty());     buf.clear();    Tree::from(tree_ref).write_to(&mut buf)?;    assert!(buf.is_empty());    Ok(())} #[test]fn everything() -> crate::Result {    let fixture = tree_fixture("everything.tree")?;    let hash_kind = crate::fixture_hash_kind();    let tree_ref = TreeRef::from_bytes(&fixture, hash_kind)?;    assert_eq!(        tree_ref,        TreeRef {            entries: vec![                EntryRef {                    mode: tree::EntryKind::BlobExecutable.into(),                    filename: b"exe".as_bstr(),                    oid: &fixture_oid("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391")                },                EntryRef {                    mode: tree::EntryKind::Blob.into(),                    filename: b"file".as_bstr(),                    oid: &fixture_oid("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391")                },                EntryRef {                    mode: tree::EntryKind::Commit.into(),                    filename: b"grit-submodule".as_bstr(),                    oid: &fixture_oid("b2d1b5d684bdfda5f922b466cc13d4ce2d635cf8")                },                EntryRef {                    mode: tree::EntryKind::Tree.into(),                    filename: b"subdir".as_bstr(),                    oid: &fixture_oid("4d5fcadc293a348e88f777dc0920f11e7d71441c")                },                EntryRef {                    mode: tree::EntryKind::Link.into(),                    filename: b"symlink".as_bstr(),                    oid: &fixture_oid("1a010b1c0f081b2e8901d55307a15c29ff30af0e")                }            ]        }    );    Ok(())} #[test]fn invalid() {    let fixture = tree_fixture("definitely-special.tree").expect("fixture is valid");    let partial_tree = &fixture[..fixture.len() / 2];    let hash_kind = crate::fixture_hash_kind();    assert!(TreeRef::from_bytes(partial_tree, hash_kind).is_err());    assert!(        TreeRefIter::from_bytes(partial_tree, hash_kind)            .take_while(Result::is_ok)            .count()            > 0,        "we can decode some entries before failing"    );} #[test]fn fuzzed() {    assert!(        gix_object::TreeRef::from_bytes(b"2", gix_testtools::object_hash()).is_err(),        "fail, but don't crash"    );} #[test]fn fuzz_artifact_inputs_can_be_parsed_without_panicking() {    for path in crate::fuzz_artifact_paths("fuzz_tree") {        let input = std::fs::read(path).expect("artifact is readable");        _ = TreeRef::from_bytes(&input, gix_hash::Kind::Sha1);        _ = TreeRef::from_bytes(&input, gix_hash::Kind::Sha256);    }} #[test]fn special_trees() -> crate::Result {    let hash_kind = crate::fixture_hash_kind();    for (name, expected_entry_count) in [        ("maybe-special", 160),        ("definitely-special", 19),        ("special-1", 5),        ("special-2", 18),        ("special-3", 5),        ("special-4", 18),        ("special-5", 17),    ] {        let fixture = tree_fixture(&format!("{name}.tree"))?;        let actual = TreeRef::from_bytes(&fixture, hash_kind)?;        assert_eq!(actual.entries.len(), expected_entry_count, "{name}");        assert_eq!(            TreeRefIter::from_bytes(&fixture, hash_kind).map(Result::unwrap).count(),            expected_entry_count,            "{name}"        );        // Show we can roundtrip        let mut buf: Vec<u8> = Default::default();        actual.write_to(&mut buf).expect("Failed to write bytes to buffer");        assert_eq!(buf, fixture);    }    Ok(())}