increase test coverage and fix more quirks

src/chrono.rs

@@ -87,8 +87,8 @@ impl TryFrom<crate::DateTime> for chrono::DateTime<chrono::FixedOffset> {
             ..
         } = iso.time;
 
-        let offset_minutes = tz_offset_hours * 3600 + tz_offset_minutes;
-        let offset = chrono::FixedOffset::east_opt(offset_minutes).ok_or(())?;
+        let offset_seconds = tz_offset_hours * 3600 + tz_offset_minutes * 60;
+        let offset = chrono::FixedOffset::east_opt(offset_seconds).ok_or(())?;
 
         let naive_time = chrono::NaiveTime::try_from(iso.time)?;
         let naive_date_time = chrono::NaiveDate::try_from(iso.date)?.and_time(naive_time);
@@ -128,7 +128,7 @@ mod test_datetime {
         assert_eq!(datetime.hour(), 23);
         assert_eq!(datetime.minute(), 40);
         assert_eq!(datetime.second(), 00);
-        assert_eq!(datetime.offset().fix().local_minus_utc(), 3623);
+        assert_eq!(datetime.offset().fix().local_minus_utc(), 4980);
     }
 
     #[test]
@@ -170,7 +170,7 @@ mod test_datetime {
         assert_eq!(datetime.hour(), 23);
         assert_eq!(datetime.minute(), 40);
         assert_eq!(datetime.second(), 00);
-        assert_eq!(datetime.offset().fix().local_minus_utc(), 3623);
+        assert_eq!(datetime.offset().fix().local_minus_utc(), 4980);
     }
 
     #[test]
@@ -183,4 +183,46 @@ mod test_datetime {
         assert_eq!(naive.second(), 15);
         assert_eq!(naive.nanosecond(), 123_000_000);
     }
+
+    #[test]
+    fn datetime_from_iso_ordinal() {
+        let iso = crate::datetime("2023-039T23:40:00+01:23").unwrap();
+        let datetime = chrono::DateTime::try_from(iso).unwrap();
+
+        assert_eq!(datetime.year(), 2023);
+        assert_eq!(datetime.month(), 2);
+        assert_eq!(datetime.day(), 8);
+        assert_eq!(datetime.hour(), 23);
+        assert_eq!(datetime.minute(), 40);
+        assert_eq!(datetime.second(), 00);
+        assert_eq!(datetime.offset().fix().local_minus_utc(), 4980);
+    }
+
+    #[test]
+    fn datetime_from_iso_ymd_negative_year() {
+        let iso = crate::datetime("-2023-039T23:40:00+01:23").unwrap();
+        let datetime = chrono::DateTime::try_from(iso).unwrap();
+
+        assert_eq!(datetime.year(), -2023);
+        assert_eq!(datetime.month(), 2);
+        assert_eq!(datetime.day(), 8);
+        assert_eq!(datetime.hour(), 23);
+        assert_eq!(datetime.minute(), 40);
+        assert_eq!(datetime.second(), 00);
+        assert_eq!(datetime.offset().fix().local_minus_utc(), 4980);
+    }
+
+    #[test]
+    fn datetime_from_iso_ymd_negative_offset() {
+        let iso = crate::datetime("2023-02-08T23:40:00-05:30").unwrap();
+        let datetime = chrono::DateTime::try_from(iso).unwrap();
+
+        assert_eq!(datetime.year(), 2023);
+        assert_eq!(datetime.month(), 2);
+        assert_eq!(datetime.day(), 8);
+        assert_eq!(datetime.hour(), 23);
+        assert_eq!(datetime.minute(), 40);
+        assert_eq!(datetime.second(), 00);
+        assert_eq!(datetime.offset().fix().local_minus_utc(), -19800);
+    }
 }

src/display.rs

@@ -2,31 +2,54 @@ use core::fmt::{self, Display};
 
 use super::{Date, DateTime, Duration, Time};
 
+fn write_year(f: &mut fmt::Formatter, year: i32) -> fmt::Result {
+    if year < 0 {
+        let year = -year;
+        write!(f, "-{year:04}")
+    } else {
+        write!(f, "{year:04}")
+    }
+}
+
 impl Display for Date {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            // like `2015-11-02`
-            Date::YMD { year, month, day } => write!(f, "{:04}-{:02}-{:02}", year, month, day),
-            // like `2015-W45-01`
-            Date::Week { year, ww, d } => write!(f, "{:04}-W{:02}-{:01}", year, ww, d),
-            // like `2015-306`
-            Date::Ordinal { year, ddd } => write!(f, "{:04}-{:03}", year, ddd),
+            Date::YMD { year, month, day } => {
+                write_year(f, year)?;
+                write!(f, "-{month:02}-{day:02}")
+            }
+            Date::Week { year, ww, d } => {
+                write_year(f, year)?;
+                write!(f, "-W{ww:02}-{d:01}")
+            }
+            Date::Ordinal { year, ddd } => {
+                write_year(f, year)?;
+                write!(f, "-{ddd:03}")
+            }
         }
     }
 }
 
 impl Display for Time {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // like `16:43:16.123+00:00`
+        let (sign, tz_offset_hours, tz_offset_minutes) =
+            if self.tz_offset_hours < 0 || self.tz_offset_minutes < 0 {
+                ('-', -self.tz_offset_hours, -self.tz_offset_minutes)
+            } else {
+                ('+', self.tz_offset_hours, self.tz_offset_minutes)
+            };
+
         write!(
             f,
-            "{:02}:{:02}:{:02}.{:03}+{:02}:{:02}",
+            "{:02}:{:02}:{:02}.{:03}{}{:02}:{:02}",
             self.hour,
             self.minute,
             self.second,
             self.millisecond,
-            self.tz_offset_hours,
-            self.tz_offset_minutes
+            sign,
+            tz_offset_hours,
+            tz_offset_minutes
         )
     }
 }
@@ -97,14 +120,14 @@ mod tests {
 
     use super::*;
 
-    fn test_duration_reparse(duration: Duration) {
+    fn assert_duration_reparse(duration: Duration) {
         let serialized = format!("{}", duration);
         let reparsed = parse_duration(serialized.as_bytes()).unwrap().1;
         assert_eq!(duration, reparsed);
     }
 
     #[test]
-    fn display_duration_0() {
+    fn duration_0() {
         let duration = Duration::YMDHMS {
             year: 2021,
             month: 11,
@@ -114,11 +137,11 @@ mod tests {
             second: 59,
             millisecond: 0,
         };
-        test_duration_reparse(duration);
+        assert_duration_reparse(duration);
     }
 
     #[test]
-    fn display_duration_1() {
+    fn duration_1() {
         let duration = Duration::YMDHMS {
             year: 2021,
             month: 11,
@@ -128,17 +151,17 @@ mod tests {
             second: 59,
             millisecond: 123,
         };
-        test_duration_reparse(duration);
+        assert_duration_reparse(duration);
     }
 
     #[test]
-    fn display_duration_2() {
+    fn duration_2() {
         let duration = Duration::Weeks(50);
-        test_duration_reparse(duration);
+        assert_duration_reparse(duration);
     }
 
     #[test]
-    fn display_duration_small_milliseconds() {
+    fn duration_small_milliseconds() {
         for millisecond in [1, 10, 100] {
             let duration = Duration::YMDHMS {
                 year: 0,
@@ -149,16 +172,99 @@ mod tests {
                 second: 0,
                 millisecond,
             };
-            test_duration_reparse(duration);
+            assert_duration_reparse(duration);
         }
     }
 
     #[test]
-    fn display_time_small_milliseconds() {
+    fn time_small_milliseconds() {
         let time = crate::time("16:43:16.001").unwrap();
         assert_eq!(format!("{}", time), "16:43:16.001+00:00");
 
         let time = crate::time("16:43:16.010").unwrap();
         assert_eq!(format!("{}", time), "16:43:16.010+00:00");
     }
+
+    fn assert_date_reparse(date: Date) {
+        let serialized = format!("{}", date);
+        let reparsed = crate::parsers::parse_date(serialized.as_bytes()).unwrap().1;
+        assert_eq!(date, reparsed);
+    }
+
+    #[test]
+    fn date_ymd() {
+        assert_date_reparse(Date::YMD {
+            year: 2015,
+            month: 6,
+            day: 26,
+        });
+    }
+
+    #[test]
+    fn date_week() {
+        assert_date_reparse(Date::Week {
+            year: 2015,
+            ww: 45,
+            d: 1,
+        });
+    }
+
+    #[test]
+    fn date_ordinal() {
+        assert_date_reparse(Date::Ordinal {
+            year: 2015,
+            ddd: 306,
+        });
+    }
+
+    #[test]
+    fn date_negative_year() {
+        assert_date_reparse(Date::YMD {
+            year: -333,
+            month: 7,
+            day: 11,
+        });
+    }
+
+    fn assert_datetime_reparse(datetime: DateTime) {
+        let serialized = format!("{}", datetime);
+        let reparsed = crate::parsers::parse_datetime(serialized.as_bytes())
+            .unwrap()
+            .1;
+        assert_eq!(datetime, reparsed);
+    }
+
+    #[test]
+    fn datetime_with_positive_offset() {
+        assert_datetime_reparse(DateTime {
+            date: Date::YMD {
+                year: 2015,
+                month: 6,
+                day: 26,
+            },
+            time: Time {
+                hour: 16,
+                minute: 43,
+                second: 16,
+                millisecond: 123,
+                tz_offset_hours: 5,
+                tz_offset_minutes: 30,
+            },
+        });
+    }
+
+    #[test]
+    fn time_with_negative_offset() {
+        let time = Time {
+            hour: 16,
+            minute: 43,
+            second: 16,
+            millisecond: 0,
+            tz_offset_hours: -5,
+            tz_offset_minutes: 0,
+        };
+        let serialized = format!("{}", time);
+        let reparsed = crate::parsers::parse_time(serialized.as_bytes()).unwrap().1;
+        assert_eq!(time, reparsed, "serialized as {:?}", serialized);
+    }
 }

src/parsers.rs

@@ -101,7 +101,7 @@ fn date_day(i: &[u8]) -> IResult<&[u8], u32> {
 
 // WW
 fn date_week(i: &[u8]) -> IResult<&[u8], u32> {
-    n_digit_in_range(i, 2, 1..=52)
+    n_digit_in_range(i, 2, 1..=53)
 }
 
 fn date_week_day(i: &[u8]) -> IResult<&[u8], u32> {

src/serde.rs

@@ -64,6 +64,66 @@ mod date {
 
         assert_eq!(deserialized_date, date);
     }
+
+    #[test]
+    fn serialize_week_date() {
+        let date_json = r#""2023-W06-2""#;
+        let date = crate::date("2023-W06-2").unwrap();
+
+        let serialized_date = serde_json::to_string(&date).unwrap();
+
+        assert_eq!(serialized_date, date_json);
+    }
+
+    #[test]
+    fn deserialize_week_date() {
+        let date_json = r#""2023-W06-2""#;
+        let date = crate::date("2023-W06-2").unwrap();
+
+        let deserialized_date = serde_json::from_str::<crate::Date>(date_json).unwrap();
+
+        assert_eq!(deserialized_date, date);
+    }
+
+    #[test]
+    fn serialize_ordinal_date() {
+        let date_json = r#""2023-039""#;
+        let date = crate::date("2023-039").unwrap();
+
+        let serialized_date = serde_json::to_string(&date).unwrap();
+
+        assert_eq!(serialized_date, date_json);
+    }
+
+    #[test]
+    fn deserialize_ordinal_date() {
+        let date_json = r#""2023-039""#;
+        let date = crate::date("2023-039").unwrap();
+
+        let deserialized_date = serde_json::from_str::<crate::Date>(date_json).unwrap();
+
+        assert_eq!(deserialized_date, date);
+    }
+
+    #[test]
+    fn serialize_negative_year() {
+        let date_json = r#""-0333-07-11""#;
+        let date = crate::date("-0333-07-11").unwrap();
+
+        let serialized_date = serde_json::to_string(&date).unwrap();
+
+        assert_eq!(serialized_date, date_json);
+    }
+
+    #[test]
+    fn deserialize_negative_year() {
+        let date_json = r#""-0333-07-11""#;
+        let date = crate::date("-0333-07-11").unwrap();
+
+        let deserialized_date = serde_json::from_str::<crate::Date>(date_json).unwrap();
+
+        assert_eq!(deserialized_date, date);
+    }
 }
 
 mod time {
@@ -256,4 +316,24 @@ mod duration {
 
         assert_eq!(deserialized_duration, duration);
     }
+
+    #[test]
+    fn serialize_weeks() {
+        let duration_json = r#""P26W""#;
+        let duration = crate::duration("P26W").unwrap();
+
+        let serialized_duration = serde_json::to_string(&duration).unwrap();
+
+        assert_eq!(serialized_duration, duration_json);
+    }
+
+    #[test]
+    fn deserialize_weeks() {
+        let duration_json = r#""P26W""#;
+        let duration = crate::duration("P26W").unwrap();
+
+        let deserialized_duration = serde_json::from_str::<crate::Duration>(duration_json).unwrap();
+
+        assert_eq!(deserialized_duration, duration);
+    }
 }