use gix_error::{    Class, CorruptionError, Error, ErrorExt, ResourceExhaustionError, ResourceExhaustionKind, RetryableError,    ValidationError, can_retry, can_retry_lenient, message,}; #[test]fn classifications_preserve_order_duplicates_and_sources() {    fn allocation_failure() -> std::collections::TryReserveError {        Vec::<u8>::new()            .try_reserve(usize::MAX)            .expect_err("the maximum capacity cannot be reserved")    }    let err = Error::from(        RetryableError::new(allocation_failure()).and_raise(CorruptionError::new("corrupt input caused allocation")),    );    let classifications = err.classify().collect::<Vec<_>>();     assert_eq!(        classifications            .iter()            .map(gix_error::Classification::class)            .collect::<Vec<_>>(),        [            Class::Corruption,            Class::Retryable,            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure),        ],        "classification follows the error graph without merging independent meanings"    );    assert!(classifications[0].error().is::<CorruptionError>());    assert!(classifications[1].error().is::<RetryableError>());    assert!(classifications[2].error().is::<std::collections::TryReserveError>());     let duplicate = Error::from(        ValidationError::new("first")            .raise()            .chain(ValidationError::new("second")),    );    assert_eq!(        duplicate.classify().map(|item| item.class()).collect::<Vec<_>>(),        [Class::Validation, Class::Validation],        "a classification is emitted for each matching error node"    );} #[test]fn io_errors_are_normalized_without_losing_their_origin() {    let cases = [        (std::io::ErrorKind::NotFound, Class::NotFound),        (            std::io::ErrorKind::OutOfMemory,            Class::ResourceExhaustion(ResourceExhaustionKind::AllocationFailure),        ),        (            std::io::ErrorKind::PermissionDenied,            Class::Io(std::io::ErrorKind::PermissionDenied),        ),    ];     for (io_kind, expected_class) in cases {        let err = Error::from_error(std::io::Error::from(io_kind));        let classification = err.classify().next().expect("all I/O errors are classified");        assert_eq!(classification.class(), expected_class);        assert_eq!(classification.io_kind(), Some(io_kind));        assert!(classification.error().is::<std::io::Error>());    }} #[test]fn allocation_limits_are_resources_only() {    let err = Error::from_error(ResourceExhaustionError::new(        ResourceExhaustionKind::AllocationLimit,        "configured allocation limit exceeded",    ));     assert_eq!(        err.classify().map(|item| item.class()).collect::<Vec<_>>(),        [Class::ResourceExhaustion(ResourceExhaustionKind::AllocationLimit)]    );    assert!(!err.is_corrupted());    assert!(!err.can_retry());} #[test]fn global_retry_policy_is_conservative() {    for kind in [std::io::ErrorKind::Interrupted, std::io::ErrorKind::TimedOut] {        assert!(            can_retry(&std::io::Error::from(kind)),            "{kind:?} can be retried globally"        );    }    for kind in [        std::io::ErrorKind::OutOfMemory,        std::io::ErrorKind::ConnectionReset,        std::io::ErrorKind::UnexpectedEof,    ] {        assert!(            !can_retry(&std::io::Error::from(kind)),            "{kind:?} needs explicit retry policy"        );    }    assert!(can_retry(&RetryableError::new(message("try again"))));} #[test]fn lenient_retry_policy_preserves_the_previous_io_kinds() {    for kind in [        std::io::ErrorKind::Interrupted,        std::io::ErrorKind::UnexpectedEof,        std::io::ErrorKind::OutOfMemory,        std::io::ErrorKind::TimedOut,        std::io::ErrorKind::BrokenPipe,        std::io::ErrorKind::AddrInUse,        std::io::ErrorKind::ConnectionAborted,        std::io::ErrorKind::ConnectionReset,        std::io::ErrorKind::ConnectionRefused,    ] {        assert!(            can_retry_lenient(&std::io::Error::from(kind)),            "{kind:?} is retryable under the lenient policy"        );    }     assert!(        !Error::from_error(std::io::Error::from(std::io::ErrorKind::PermissionDenied)).can_retry_lenient(),        "the lenient policy still rejects permanent I/O errors"    );    assert!(        Error::from_error(RetryableError::new(message("try again"))).can_retry_lenient(),        "the lenient policy includes explicitly retryable errors"    );    let allocation_failure = Vec::<u8>::new()        .try_reserve(usize::MAX)        .expect_err("the maximum capacity cannot be reserved");    assert!(        !Error::from_error(allocation_failure).can_retry_lenient(),        "only I/O OutOfMemory errors are covered by the historical policy"    );} #[test]fn unknown_errors_are_omitted() {    assert_eq!(Error::from_error(message("unknown")).classify().count(), 0);}