Deduplicate test helpers using Display and expect_in_range

Replace hand-rolled format_offset_colon / format_for_assert helpers
with the new Display impls. Replace local expect_in_range_datetime
test helpers with ParsedDateTime::expect_in_range().

src/items/builder.rs

@@ -538,7 +538,7 @@ impl TryFrom<Vec<Item>> for DateTimeBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use jiff::{civil::DateTime, tz::TimeZone, Zoned};
+    use jiff::{civil::DateTime, tz::TimeZone};
 
     fn timestamp() -> epoch::Timestamp {
         let mut input = "@1234567890";
@@ -630,13 +630,6 @@ mod tests {
         }
     }
 
-    fn expect_in_range_datetime(parsed: ParsedDateTime) -> Zoned {
-        match parsed {
-            ParsedDateTime::InRange(z) => z,
-            ParsedDateTime::Extended(dt) => panic!("expected in-range datetime, got {dt:?}"),
-        }
-    }
-
     #[test]
     fn duplicate_items_error() {
         let test_cases = vec![
@@ -919,7 +912,7 @@ mod tests {
             Item::Relative(relative_day()),
         ])
         .unwrap();
-        let z = expect_in_range_datetime(builder.set_base(base).build().unwrap());
+        let z = builder.set_base(base).build().unwrap().expect_in_range();
         assert_eq!(z.strftime("%Y-%m-%d").to_string(), "9999-02-01");
     }
 
@@ -953,7 +946,7 @@ mod tests {
             Item::Relative(relative_month()),
         ])
         .unwrap();
-        let z = expect_in_range_datetime(builder.set_base(base).build().unwrap());
+        let z = builder.set_base(base).build().unwrap().expect_in_range();
         assert_eq!(z.strftime("%Y-%m-%d").to_string(), "2021-03-03");
     }
 
@@ -995,7 +988,7 @@ mod tests {
             .unwrap();
         let mut builder = DateTimeBuilder::new();
         builder.base = Some(base);
-        let z = expect_in_range_datetime(builder.build_extended().unwrap());
+        let z = builder.build_extended().unwrap().expect_in_range();
         assert_eq!(
             z.strftime("%Y-%m-%d %H:%M:%S%.9f").to_string(),
             "2000-01-01 10:11:12.123456789"
@@ -1019,12 +1012,12 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "expected in-range datetime")]
+    #[should_panic(expected = "ParsedDateTime is not representable as jiff::Zoned")]
-    fn expect_in_range_datetime_panics_for_extended_input() {
+    fn expect_in_range_panics_for_extended_input() {
         let parsed = DateTimeBuilder::try_from(vec![Item::Date(date_large("10000-01-01"))])
             .unwrap()
             .build()
             .unwrap();
-        let _ = expect_in_range_datetime(parsed);
+        let _ = parsed.expect_in_range();
     }
 }

src/items/mod.rs

@@ -300,33 +300,13 @@ mod tests {
             .to_string()
     }
 
-    fn format_offset_colon(seconds: i32) -> String {
-        let sign = if seconds < 0 { '-' } else { '+' };
-        let abs = seconds.unsigned_abs();
-        let hours = abs / 3600;
-        let minutes = (abs % 3600) / 60;
-        format!("{sign}{hours:02}:{minutes:02}")
-    }
-
     fn assert_extended_datetime(input: &str, base: Zoned, expected: &str) {
-        match parse_at_date(base, input).unwrap() {
+        let parsed = parse_at_date(base, input).unwrap();
-            ParsedDateTime::Extended(dt) => {
+        assert!(
-                let actual = format!(
+            matches!(parsed, ParsedDateTime::Extended(_)),
-                    "{:04}-{:02}-{:02} {:02}:{:02}:{:02}{}",
+            "expected extended datetime, got in-range for: {input}"
-                    dt.year,
+        );
-                    dt.month,
+        assert_eq!(parsed.to_string(), expected, "{input}");
-                    dt.day,
-                    dt.hour,
-                    dt.minute,
-                    dt.second,
-                    format_offset_colon(dt.offset_seconds)
-                );
-                assert_eq!(actual, expected, "{input}");
-            }
-            ParsedDateTime::InRange(z) => {
-                panic!("expected extended datetime, got in-range: {z}");
-            }
-        }
     }
 
     fn expect_extended_datetime(parsed: ParsedDateTime) -> crate::ExtendedDateTime {
@@ -336,13 +316,6 @@ mod tests {
         }
     }
 
-    fn expect_in_range_datetime(parsed: ParsedDateTime) -> Zoned {
-        match parsed {
-            ParsedDateTime::InRange(z) => z,
-            ParsedDateTime::Extended(dt) => panic!("expected in-range datetime, got {dt:?}"),
-        }
-    }
-
     #[test]
     fn date_and_time() {
         assert_eq!(
@@ -600,7 +573,7 @@ mod tests {
             .to_zoned(TimeZone::UTC)
             .unwrap();
         let result = parse_at_date(base, "10000-01-01 -1000 years").unwrap();
-        let z = expect_in_range_datetime(result);
+        let z = result.expect_in_range();
         assert_eq!(
             z.strftime("%Y-%m-%d %H:%M:%S%:z").to_string(),
             "9000-01-01 00:00:00+00:00"
@@ -615,7 +588,7 @@ mod tests {
             .to_zoned(TimeZone::UTC)
             .unwrap();
         let result = parse_at_date(base, "TZ=\"Europe/Paris\" 10000-01-01 -1000 years").unwrap();
-        let z = expect_in_range_datetime(result);
+        let z = result.expect_in_range();
         assert_eq!(
             z.strftime("%Y-%m-%d %H:%M:%S%:z").to_string(),
             "9000-01-01 00:00:00+01:00"
@@ -659,15 +632,15 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "expected in-range datetime")]
+    #[should_panic(expected = "ParsedDateTime is not representable as jiff::Zoned")]
-    fn expect_in_range_datetime_panics_for_extended_input() {
+    fn expect_in_range_panics_for_extended_input() {
         let base = "2000-01-01 00:00:00"
             .parse::<DateTime>()
             .unwrap()
             .to_zoned(TimeZone::UTC)
             .unwrap();
         let parsed = parse_at_date(base, "10000-01-01").unwrap();
-        let _ = expect_in_range_datetime(parsed);
+        let _ = parsed.expect_in_range();
     }
 
     #[test]

tests/common/mod.rs

@@ -4,31 +4,7 @@
 use std::env;
 
 use jiff::Zoned;
-use parse_datetime::{parse_datetime, parse_datetime_at_date, ParsedDateTime};
+use parse_datetime::{parse_datetime, parse_datetime_at_date};
-
-fn format_offset_colon(seconds: i32) -> String {
-    let sign = if seconds < 0 { '-' } else { '+' };
-    let abs = seconds.unsigned_abs();
-    let h = abs / 3600;
-    let m = (abs % 3600) / 60;
-    format!("{sign}{h:02}:{m:02}")
-}
-
-fn format_for_assert(parsed: ParsedDateTime) -> String {
-    match parsed {
-        ParsedDateTime::InRange(z) => z.strftime("%Y-%m-%d %H:%M:%S%:z").to_string(),
-        ParsedDateTime::Extended(dt) => format!(
-            "{:04}-{:02}-{:02} {:02}:{:02}:{:02}{}",
-            dt.year,
-            dt.month,
-            dt.day,
-            dt.hour,
-            dt.minute,
-            dt.second,
-            format_offset_colon(dt.offset_seconds)
-        ),
-    }
-}
 
 pub fn check_absolute(input: &str, expected: &str) {
     env::set_var("TZ", "UTC0");
@@ -38,7 +14,7 @@ pub fn check_absolute(input: &str, expected: &str) {
         Err(e) => panic!("Failed to parse date from value '{input}': {e}"),
     };
 
-    assert_eq!(format_for_assert(parsed), expected, "Input value: {input}");
+    assert_eq!(parsed.to_string(), expected, "Input value: {input}");
 }
 
 pub fn check_relative(now: Zoned, input: &str, expected: &str) {
@@ -49,5 +25,5 @@ pub fn check_relative(now: Zoned, input: &str, expected: &str) {
         Err(e) => panic!("Failed to parse date from value '{input}': {e}"),
     };
 
-    assert_eq!(format_for_assert(parsed), expected, "Input value: {input}");
+    assert_eq!(parsed.to_string(), expected, "Input value: {input}");
 }