use std::{collections::HashMap, time::SystemTime}; use git_date::time::{format, Format};use once_cell::sync::Lazy; type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>; struct Sample {    format_name: Option<String>,    exit_code: usize,    time_in_seconds_since_unix_epoch: u32,} static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {    (|| -> Result<_> {        let base = git_testtools::scripted_fixture_read_only("generate_git_date_baseline.sh")?;        let mut map = HashMap::new();        let file = std::fs::read(base.join("baseline.git"))?;        let baseline = std::str::from_utf8(&file).expect("valid utf");        let mut lines = baseline.lines();        while let Some(date_str) = lines.next() {            let format_name = lines.next().expect("four lines per baseline").to_string();            let exit_code = lines.next().expect("four lines per baseline").parse()?;            let time_in_seconds_since_unix_epoch: u32 = lines                .next()                .expect("four lines per baseline")                .parse()                .expect("valid epoch value");            map.insert(                date_str.into(),                Sample {                    format_name: (!format_name.is_empty()).then(|| format_name),                    exit_code,                    time_in_seconds_since_unix_epoch,                },            );        }        Ok(map)    })()    .expect("baseline format is well known and can always be parsed")}); #[test]fn parse_compare_format() {    for (        pattern,        Sample {            format_name,            exit_code,            time_in_seconds_since_unix_epoch,        },    ) in BASELINE.iter()    {        let res = git_date::parse(pattern.as_str(), Some(SystemTime::now()));        assert_eq!(            res.is_ok(),            *exit_code == 0,            "{pattern:?} disagrees with baseline: {res:?}"        );        if let Ok(t) = res {            let actual = t.seconds_since_unix_epoch;            assert_eq!(                actual, *time_in_seconds_since_unix_epoch,                "{pattern:?} disagrees with baseline seconds since epoch: {actual:?}"            );            if let Some(format_name) = format_name {                let reformatted = t.format(match format_name.as_str() {                    "RFC2822" => Format::Custom(format::RFC2822),                    "ISO8601" => Format::Custom(format::ISO8601),                    "ISO8601_STRICT" => Format::Custom(format::ISO8601_STRICT),                    "DEFAULT" => Format::Custom(format::DEFAULT),                    "UNIX" => Format::Unix,                    "RAW" => Format::Raw,                    unknown => unreachable!("All formats should be well-known and implemented: {unknown:?}"),                });                assert_eq!(                    reformatted, *pattern,                    "{reformatted:?} disagrees with baseline pattern: {pattern:?}"                );            }        }    }}