diff --git a/src/datetime.rs b/src/datetime.rs index 417fee0e..a5594cad 100644 --- a/src/datetime.rs +++ b/src/datetime.rs @@ -2776,7 +2776,7 @@ mod tests { fn test_rfc3339_opts() { use SecondsFormat::*; let pst = FixedOffset::east(8 * 60 * 60); - let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 084_660_000); + let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 84_660_000); assert_eq!(dt.to_rfc3339_opts(Secs, false), "2018-01-11T10:05:13+08:00"); assert_eq!(dt.to_rfc3339_opts(Secs, true), "2018-01-11T10:05:13+08:00"); assert_eq!(dt.to_rfc3339_opts(Millis, false), "2018-01-11T10:05:13.084+08:00"); @@ -3003,7 +3003,7 @@ mod tests { #[test] fn test_datetime_format_alignment() { - let datetime = Utc.ymd(2007, 01, 02); + let datetime = Utc.ymd(2007, 1, 2); // Item::Literal let percent = datetime.format("%%"); diff --git a/src/format/parse.rs b/src/format/parse.rs index 4d63f963..175e4c66 100644 --- a/src/format/parse.rs +++ b/src/format/parse.rs @@ -568,7 +568,7 @@ fn test_parse() { check!(" \t987", [num!(Year)]; year: 987); check!("5", [num!(Year)]; year: 5); check!("5\0", [num!(Year)]; TOO_LONG); - check!("\05", [num!(Year)]; INVALID); + check!("\x005", [num!(Year)]; INVALID); check!("", [num!(Year)]; TOO_SHORT); check!("12345", [num!(Year), lit!("5")]; year: 1234); check!("12345", [nums!(Year), lit!("5")]; year: 1234); diff --git a/src/format/parsed.rs b/src/format/parsed.rs index b8ed2d90..cebbafcb 100644 --- a/src/format/parsed.rs +++ b/src/format/parsed.rs @@ -23,7 +23,7 @@ use {Datelike, Timelike}; /// - `to_*` methods try to make a concrete date and time value out of set fields. /// It fully checks any remaining out-of-range conditions and inconsistent/impossible fields. #[allow(missing_copy_implementations)] -#[derive(Clone, PartialEq, Debug)] +#[derive(Clone, PartialEq, Debug, Default)] pub struct Parsed { /// Year. /// @@ -126,34 +126,6 @@ fn set_if_consistent(old: &mut Option, new: T) -> ParseResult<( } } -impl Default for Parsed { - fn default() -> Parsed { - Parsed { - year: None, - year_div_100: None, - year_mod_100: None, - isoyear: None, - isoyear_div_100: None, - isoyear_mod_100: None, - month: None, - week_from_sun: None, - week_from_mon: None, - isoweek: None, - weekday: None, - ordinal: None, - day: None, - hour_div_12: None, - hour_mod_12: None, - minute: None, - second: None, - nanosecond: None, - timestamp: None, - offset: None, - _dummy: (), - } - } -} - impl Parsed { /// Returns the initial value of parsed parts. pub fn new() -> Parsed { diff --git a/src/format/scan.rs b/src/format/scan.rs index 0efb1ee3..581ed4ef 100644 --- a/src/format/scan.rs +++ b/src/format/scan.rs @@ -317,7 +317,7 @@ pub fn timezone_offset_2822(s: &str) -> ParseResult<(&str, Option)> { b'a'...b'z' | b'A'...b'Z' => false, _ => true, }) - .unwrap_or_else(|| s.len()); + .unwrap_or(s.len()); if upto > 0 { let name = &s[..upto]; let s = &s[upto..]; diff --git a/src/format/strftime.rs b/src/format/strftime.rs index 93820a23..c6e3e721 100644 --- a/src/format/strftime.rs +++ b/src/format/strftime.rs @@ -462,7 +462,7 @@ impl<'a> Iterator for StrftimeItems<'a> { let nextspec = self .remainder .find(|c: char| !c.is_whitespace()) - .unwrap_or_else(|| self.remainder.len()); + .unwrap_or(self.remainder.len()); assert!(nextspec > 0); let item = sp!(&self.remainder[..nextspec]); self.remainder = &self.remainder[nextspec..]; @@ -474,7 +474,7 @@ impl<'a> Iterator for StrftimeItems<'a> { let nextspec = self .remainder .find(|c: char| c.is_whitespace() || c == '%') - .unwrap_or_else(|| self.remainder.len()); + .unwrap_or(self.remainder.len()); assert!(nextspec > 0); let item = lit!(&self.remainder[..nextspec]); self.remainder = &self.remainder[nextspec..]; @@ -487,11 +487,11 @@ impl<'a> Iterator for StrftimeItems<'a> { #[cfg(test)] #[test] fn test_strftime_items() { - fn parse_and_collect<'a>(s: &'a str) -> Vec> { + fn parse_and_collect(s: &str) -> Vec> { // map any error into `[Item::Error]`. useful for easy testing. let items = StrftimeItems::new(s); let items = items.map(|spec| if spec == Item::Error { None } else { Some(spec) }); - items.collect::>>().unwrap_or(vec![Item::Error]) + items.collect::>>().unwrap_or_else(|| vec![Item::Error]) } assert_eq!(parse_and_collect(""), []); diff --git a/src/naive/date.rs b/src/naive/date.rs index 34cdc2c5..9cd00e7d 100644 --- a/src/naive/date.rs +++ b/src/naive/date.rs @@ -42,7 +42,7 @@ const MAX_DAYS_FROM_YEAR_0: i32 = const MIN_DAYS_FROM_YEAR_0: i32 = (MIN_YEAR + 400_000) * 365 + (MIN_YEAR + 400_000) / 4 - (MIN_YEAR + 400_000) / 100 + (MIN_YEAR + 400_000) / 400 - - 146097_000; + - 146_097_000; #[cfg(test)] // only used for testing, but duplicated in naive::datetime const MAX_BITS: usize = 44; @@ -1912,7 +1912,7 @@ mod tests { #[test] fn test_date_from_ymd() { - let ymd_opt = |y, m, d| NaiveDate::from_ymd_opt(y, m, d); + let ymd_opt = NaiveDate::from_ymd_opt; assert!(ymd_opt(2012, 0, 1).is_none()); assert!(ymd_opt(2012, 1, 1).is_some()); @@ -1928,8 +1928,8 @@ mod tests { #[test] fn test_date_from_yo() { - let yo_opt = |y, o| NaiveDate::from_yo_opt(y, o); - let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d); + let yo_opt = NaiveDate::from_yo_opt; + let ymd = NaiveDate::from_ymd; assert_eq!(yo_opt(2012, 0), None); assert_eq!(yo_opt(2012, 1), Some(ymd(2012, 1, 1))); @@ -1958,8 +1958,8 @@ mod tests { #[test] fn test_date_from_isoywd() { - let isoywd_opt = |y, w, d| NaiveDate::from_isoywd_opt(y, w, d); - let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d); + let isoywd_opt = NaiveDate::from_isoywd_opt; + let ymd = NaiveDate::from_ymd; assert_eq!(isoywd_opt(2004, 0, Weekday::Sun), None); assert_eq!(isoywd_opt(2004, 1, Weekday::Mon), Some(ymd(2003, 12, 29))); @@ -2001,8 +2001,7 @@ mod tests { .iter() { let d = NaiveDate::from_isoywd_opt(year, week, weekday); - if d.is_some() { - let d = d.unwrap(); + if let Some(d) = d { assert_eq!(d.weekday(), weekday); let w = d.iso_week(); assert_eq!(w.year(), year); @@ -2016,8 +2015,7 @@ mod tests { for month in 1..13 { for day in 1..32 { let d = NaiveDate::from_ymd_opt(year, month, day); - if d.is_some() { - let d = d.unwrap(); + if let Some(d) = d { let w = d.iso_week(); let d_ = NaiveDate::from_isoywd(w.year(), w.week(), d.weekday()); assert_eq!(d, d_); @@ -2029,7 +2027,7 @@ mod tests { #[test] fn test_date_from_num_days_from_ce() { - let from_ndays_from_ce = |days| NaiveDate::from_num_days_from_ce_opt(days); + let from_ndays_from_ce = NaiveDate::from_num_days_from_ce_opt; assert_eq!(from_ndays_from_ce(1), Some(NaiveDate::from_ymd(1, 1, 1))); assert_eq!(from_ndays_from_ce(2), Some(NaiveDate::from_ymd(1, 1, 2))); assert_eq!(from_ndays_from_ce(31), Some(NaiveDate::from_ymd(1, 1, 31))); @@ -2037,7 +2035,7 @@ mod tests { assert_eq!(from_ndays_from_ce(59), Some(NaiveDate::from_ymd(1, 2, 28))); assert_eq!(from_ndays_from_ce(60), Some(NaiveDate::from_ymd(1, 3, 1))); assert_eq!(from_ndays_from_ce(365), Some(NaiveDate::from_ymd(1, 12, 31))); - assert_eq!(from_ndays_from_ce(365 * 1 + 1), Some(NaiveDate::from_ymd(2, 1, 1))); + assert_eq!(from_ndays_from_ce(365 + 1), Some(NaiveDate::from_ymd(2, 1, 1))); assert_eq!(from_ndays_from_ce(365 * 2 + 1), Some(NaiveDate::from_ymd(3, 1, 1))); assert_eq!(from_ndays_from_ce(365 * 3 + 1), Some(NaiveDate::from_ymd(4, 1, 1))); assert_eq!(from_ndays_from_ce(365 * 4 + 2), Some(NaiveDate::from_ymd(5, 1, 1))); @@ -2060,7 +2058,7 @@ mod tests { #[test] fn test_date_from_weekday_of_month_opt() { - let ymwd = |y, m, w, n| NaiveDate::from_weekday_of_month_opt(y, m, w, n); + let ymwd = NaiveDate::from_weekday_of_month_opt; assert_eq!(ymwd(2018, 8, Weekday::Tue, 0), None); assert_eq!(ymwd(2018, 8, Weekday::Wed, 1), Some(NaiveDate::from_ymd(2018, 8, 1))); assert_eq!(ymwd(2018, 8, Weekday::Thu, 1), Some(NaiveDate::from_ymd(2018, 8, 2))); @@ -2176,7 +2174,7 @@ mod tests { #[test] fn test_date_succ() { - let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d); + let ymd = NaiveDate::from_ymd; assert_eq!(ymd(2014, 5, 6).succ_opt(), Some(ymd(2014, 5, 7))); assert_eq!(ymd(2014, 5, 31).succ_opt(), Some(ymd(2014, 6, 1))); assert_eq!(ymd(2014, 12, 31).succ_opt(), Some(ymd(2015, 1, 1))); @@ -2186,7 +2184,7 @@ mod tests { #[test] fn test_date_pred() { - let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d); + let ymd = NaiveDate::from_ymd; assert_eq!(ymd(2016, 3, 1).pred_opt(), Some(ymd(2016, 2, 29))); assert_eq!(ymd(2015, 1, 1).pred_opt(), Some(ymd(2014, 12, 31))); assert_eq!(ymd(2014, 6, 1).pred_opt(), Some(ymd(2014, 5, 31))); @@ -2334,7 +2332,7 @@ mod tests { #[test] fn test_date_parse_from_str() { - let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d); + let ymd = NaiveDate::from_ymd; assert_eq!( NaiveDate::parse_from_str("2014-5-7T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"), Ok(ymd(2014, 5, 7)) @@ -2392,17 +2390,11 @@ mod tests { #[test] fn test_day_iterator_limit() { - assert_eq!( - NaiveDate::from_ymd(262143, 12, 29).iter_days().take(4).collect::>().len(), - 2 - ); + assert_eq!(NaiveDate::from_ymd(262143, 12, 29).iter_days().take(4).count(), 2); } #[test] fn test_week_iterator_limit() { - assert_eq!( - NaiveDate::from_ymd(262143, 12, 12).iter_weeks().take(4).collect::>().len(), - 2 - ); + assert_eq!(NaiveDate::from_ymd(262143, 12, 12).iter_weeks().take(4).count(), 2); } } diff --git a/src/naive/time.rs b/src/naive/time.rs index 5f3966b9..43f4dd25 100644 --- a/src/naive/time.rs +++ b/src/naive/time.rs @@ -1623,7 +1623,7 @@ mod tests { }}; } - let hmsm = |h, m, s, mi| NaiveTime::from_hms_milli(h, m, s, mi); + let hmsm = NaiveTime::from_hms_milli; check!(hmsm(3, 5, 7, 900), Duration::zero(), hmsm(3, 5, 7, 900)); check!(hmsm(3, 5, 7, 900), Duration::milliseconds(100), hmsm(3, 5, 8, 0)); @@ -1702,7 +1702,7 @@ mod tests { }}; } - let hmsm = |h, m, s, mi| NaiveTime::from_hms_milli(h, m, s, mi); + let hmsm = NaiveTime::from_hms_milli; check!(hmsm(3, 5, 7, 900), hmsm(3, 5, 7, 900), Duration::zero()); check!(hmsm(3, 5, 7, 900), hmsm(3, 5, 7, 600), Duration::milliseconds(300)); @@ -1787,7 +1787,7 @@ mod tests { #[test] fn test_time_parse_from_str() { - let hms = |h, m, s| NaiveTime::from_hms(h, m, s); + let hms = NaiveTime::from_hms; assert_eq!( NaiveTime::parse_from_str("2014-5-7T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"), Ok(hms(12, 34, 56)) diff --git a/src/round.rs b/src/round.rs index 61f53d34..a8eb60d0 100644 --- a/src/round.rs +++ b/src/round.rs @@ -309,17 +309,17 @@ mod tests { #[test] fn test_round_subsecs() { let pst = FixedOffset::east(8 * 60 * 60); - let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 084_660_684); + let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 84_660_684); assert_eq!(dt.round_subsecs(10), dt); assert_eq!(dt.round_subsecs(9), dt); - assert_eq!(dt.round_subsecs(8).nanosecond(), 084_660_680); - assert_eq!(dt.round_subsecs(7).nanosecond(), 084_660_700); - assert_eq!(dt.round_subsecs(6).nanosecond(), 084_661_000); - assert_eq!(dt.round_subsecs(5).nanosecond(), 084_660_000); - assert_eq!(dt.round_subsecs(4).nanosecond(), 084_700_000); - assert_eq!(dt.round_subsecs(3).nanosecond(), 085_000_000); - assert_eq!(dt.round_subsecs(2).nanosecond(), 080_000_000); + assert_eq!(dt.round_subsecs(8).nanosecond(), 84_660_680); + assert_eq!(dt.round_subsecs(7).nanosecond(), 84_660_700); + assert_eq!(dt.round_subsecs(6).nanosecond(), 84_661_000); + assert_eq!(dt.round_subsecs(5).nanosecond(), 84_660_000); + assert_eq!(dt.round_subsecs(4).nanosecond(), 84_700_000); + assert_eq!(dt.round_subsecs(3).nanosecond(), 85_000_000); + assert_eq!(dt.round_subsecs(2).nanosecond(), 80_000_000); assert_eq!(dt.round_subsecs(1).nanosecond(), 100_000_000); assert_eq!(dt.round_subsecs(0).nanosecond(), 0); @@ -352,17 +352,17 @@ mod tests { #[test] fn test_trunc_subsecs() { let pst = FixedOffset::east(8 * 60 * 60); - let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 084_660_684); + let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 84_660_684); assert_eq!(dt.trunc_subsecs(10), dt); assert_eq!(dt.trunc_subsecs(9), dt); - assert_eq!(dt.trunc_subsecs(8).nanosecond(), 084_660_680); - assert_eq!(dt.trunc_subsecs(7).nanosecond(), 084_660_600); - assert_eq!(dt.trunc_subsecs(6).nanosecond(), 084_660_000); - assert_eq!(dt.trunc_subsecs(5).nanosecond(), 084_660_000); - assert_eq!(dt.trunc_subsecs(4).nanosecond(), 084_600_000); - assert_eq!(dt.trunc_subsecs(3).nanosecond(), 084_000_000); - assert_eq!(dt.trunc_subsecs(2).nanosecond(), 080_000_000); + assert_eq!(dt.trunc_subsecs(8).nanosecond(), 84_660_680); + assert_eq!(dt.trunc_subsecs(7).nanosecond(), 84_660_600); + assert_eq!(dt.trunc_subsecs(6).nanosecond(), 84_660_000); + assert_eq!(dt.trunc_subsecs(5).nanosecond(), 84_660_000); + assert_eq!(dt.trunc_subsecs(4).nanosecond(), 84_600_000); + assert_eq!(dt.trunc_subsecs(3).nanosecond(), 84_000_000); + assert_eq!(dt.trunc_subsecs(2).nanosecond(), 80_000_000); assert_eq!(dt.trunc_subsecs(1).nanosecond(), 0); assert_eq!(dt.trunc_subsecs(0).nanosecond(), 0); @@ -432,7 +432,7 @@ mod tests { ); // timezone east - let dt = FixedOffset::east(1 * 3600).ymd(2020, 10, 27).and_hms(15, 0, 0); + let dt = FixedOffset::east(3600).ymd(2020, 10, 27).and_hms(15, 0, 0); assert_eq!( dt.duration_round(Duration::days(1)).unwrap().to_string(), "2020-10-28 00:00:00 +01:00" @@ -443,7 +443,7 @@ mod tests { ); // timezone west - let dt = FixedOffset::west(1 * 3600).ymd(2020, 10, 27).and_hms(15, 0, 0); + let dt = FixedOffset::west(3600).ymd(2020, 10, 27).and_hms(15, 0, 0); assert_eq!( dt.duration_round(Duration::days(1)).unwrap().to_string(), "2020-10-28 00:00:00 -01:00" @@ -505,7 +505,7 @@ mod tests { #[test] fn test_duration_trunc() { - let dt = Utc.ymd(2016, 12, 31).and_hms_nano(23, 59, 59, 1_75_500_000); + let dt = Utc.ymd(2016, 12, 31).and_hms_nano(23, 59, 59, 175_500_000); assert_eq!( dt.duration_trunc(Duration::milliseconds(10)).unwrap().to_string(), @@ -542,7 +542,7 @@ mod tests { ); // timezone east - let dt = FixedOffset::east(1 * 3600).ymd(2020, 10, 27).and_hms(15, 0, 0); + let dt = FixedOffset::east(3600).ymd(2020, 10, 27).and_hms(15, 0, 0); assert_eq!( dt.duration_trunc(Duration::days(1)).unwrap().to_string(), "2020-10-27 00:00:00 +01:00" @@ -553,7 +553,7 @@ mod tests { ); // timezone west - let dt = FixedOffset::west(1 * 3600).ymd(2020, 10, 27).and_hms(15, 0, 0); + let dt = FixedOffset::west(3600).ymd(2020, 10, 27).and_hms(15, 0, 0); assert_eq!( dt.duration_trunc(Duration::days(1)).unwrap().to_string(), "2020-10-27 00:00:00 -01:00" @@ -566,7 +566,7 @@ mod tests { #[test] fn test_duration_trunc_naive() { - let dt = Utc.ymd(2016, 12, 31).and_hms_nano(23, 59, 59, 1_75_500_000).naive_utc(); + let dt = Utc.ymd(2016, 12, 31).and_hms_nano(23, 59, 59, 175_500_000).naive_utc(); assert_eq!( dt.duration_trunc(Duration::milliseconds(10)).unwrap().to_string(),