git-date parse draft

git-date/tests/fixtures/generate_git_date_baseline.sh

@@ -7,18 +7,25 @@ function baseline() {
     local test_date=$1 # first argument is the date to test
 
     git -c section.key="$test_date" config --type=expiry-date section.key && status=0 || status=$?
-#    git ls-files "$pathspec" && status=0 || status=$?
     {
         echo "$test_date"
         echo "$status"
+        if [ $status == 0 ]
+        then
+          git -c section.key="$test_date" config --type=expiry-date section.key
+        else
+          echo "-1"
+        fi
     } >> baseline.git
 }
 
 # success
 
 # date formats following to https://git-scm.com/docs/git-log#Documentation/git-log.txt---dateltformatgt
+
 # short
-baseline '2022-08-22'
+# ODO
+#baseline '2022-08-22'
 # rfc2822
 baseline 'Thu, 18 Aug 2022 12:45:06 +0800'
 # iso8601

git-date/tests/time/parse.rs

@@ -3,20 +3,22 @@ use git_date::time::Sign;
 use git_date::Time;
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
+use std::str::FromStr;
 use time::OffsetDateTime;
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 
-static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {
+static BASELINE: Lazy<HashMap<BString, (usize, BString)>> = 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("two lines per baseline").to_str()?.parse()?;
-            map.insert(date_str.into(), exit_code);
+            let exit_code = lines.next().expect("three lines per baseline").to_str()?.parse()?;
+            let output = lines.next().expect("three lines per baseline").into();
+            map.insert(date_str.into(), (exit_code, output));
         }
         Ok(map)
     })()
@@ -25,13 +27,18 @@ static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {
 
 #[test]
 fn baseline() {
-    for (pattern, exit_code) in BASELINE.iter() {
+    for (pattern, (exit_code, output)) in BASELINE.iter() {
         let res = git_date::parse(pattern.to_str().expect("valid pattern"));
         assert_eq!(
             res.is_some(),
             *exit_code == 0,
             "{pattern:?} disagrees with baseline: {res:?}"
-        )
+        );
+        if *exit_code == 0 {
+            let actual = res.unwrap().seconds_since_unix_epoch;
+            let expected = u32::from_str(output.to_str().expect("valid utf")).expect("valid epoch value");
+            assert_eq!(actual, expected, "{pattern:?} disagrees with baseline: {res:?}")
+        }
     }
 }