use std::{collections::HashMap, time::SystemTime}; use bstr::{BString, ByteSlice};use git_date::{time::Sign, Time};use once_cell::sync::Lazy; type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>; static BASELINE: Lazy<HashMap<BString, (usize, u32)>> = Lazy::new(|| {    let base = git_testtools::scripted_fixture_repo_read_only("generate_git_date_baseline.sh").unwrap();     (|| -> Result<_> {        let mut map = HashMap::new();        let baseline = std::fs::read(base.join("baseline.git"))?;        let mut lines = baseline.lines();        while let Some(date_str) = lines.next() {            let exit_code = lines.next().expect("three lines per baseline").to_str()?.parse()?;            let output: u32 = lines                .next()                .expect("three lines per baseline")                .to_str()                .expect("valid utf")                .parse()                .expect("valid epoch value");            map.insert(date_str.into(), (exit_code, output));        }        Ok(map)    })()    .unwrap()}); #[test]fn baseline() {    for (pattern, (exit_code, output)) in BASELINE.iter() {        let res = git_date::parse(pattern.to_str().expect("valid pattern"), Some(SystemTime::now()));        assert_eq!(            res.is_ok(),            *exit_code == 0,            "{pattern:?} disagrees with baseline: {res:?}"        );        if *exit_code == 0 {            let actual = res.unwrap().seconds_since_unix_epoch;            assert_eq!(actual, *output, "{pattern:?} disagrees with baseline: {actual:?}")        }    }} #[test]fn special_time_is_ok_for_now() {    assert_eq!(        git_date::parse("1979-02-26 18:30:00", Some(SystemTime::now())).unwrap(),        Time {            seconds_since_unix_epoch: 42,            offset_in_seconds: 1800,            sign: Sign::Plus,        }    );} #[test]fn short() {    assert_eq!(        git_date::parse("1979-02-26", Some(SystemTime::now())).expect("parsed date"),        Time {            seconds_since_unix_epoch: 288835200,            offset_in_seconds: 0,            sign: Sign::Plus,        },        "could not parse with SHORT format"    );} #[test]fn rfc2822() {    assert_eq!(        git_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", None).expect("parsed rfc2822 string"),        Time {            seconds_since_unix_epoch: 1660797906,            offset_in_seconds: 28800,            sign: Sign::Plus,        },        "could not parse with RFC2822 format"    );} #[test]fn invalid_dates_can_be_produced_without_current_time() {    assert!(matches!(        git_date::parse("foobar", None).unwrap_err(),        git_date::parse::Error::InvalidDateString    ));} mod relative {    use std::time::SystemTime;     use git_date::{parse::Error, time::Sign};    use time::{Duration, OffsetDateTime};     #[test]    fn large_offsets() {        git_date::parse("999999999999999 weeks ago", Some(std::time::UNIX_EPOCH)).ok();    }     #[test]    #[should_panic] // TODO: fix    fn large_offsets_can_panic_elsewhere() {        git_date::parse("9999999999 weeks ago", Some(std::time::UNIX_EPOCH)).ok();    }     #[test]    fn offset_leading_to_before_unix_epoch_cannot_be_represented() {        let err = git_date::parse("1 second ago", Some(std::time::UNIX_EPOCH)).unwrap_err();        assert!(matches!(err, Error::TooEarly{timestamp} if timestamp == -1));    }     #[test]    fn various() {        let now = Some(SystemTime::now());        let two_weeks_ago = git_date::parse("2 weeks ago", now).expect("valid time");        assert_eq!(Sign::Plus, two_weeks_ago.sign);        assert_eq!(0, two_weeks_ago.offset_in_seconds);        let expected = OffsetDateTime::from(now.unwrap()).saturating_sub(Duration::weeks(2));        // account for the loss of precision when creating `Time` with seconds        let expected = expected.replace_nanosecond(0).unwrap();        assert_eq!(            OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds_since_unix_epoch as i64).expect("valid datetime"),            expected,            "relative times differ"        );    }}