Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 7691 insertions, 0 deletions

diff --git a/third_party/rust/chrono/src/naive/date.rs b/third_party/rust/chrono/src/naive/date.rs
new file mode 100644
index 0000000000..3e34e20741
--- /dev/null
+++ b/third_party/rust/chrono/src/naive/date.rs
@@ -0,0 +1,2392 @@
+// This is a part of Chrono.
+// See README.md and LICENSE.txt for details.
+
+//! ISO 8601 calendar date without timezone.
+
+#[cfg(any(feature = "alloc", feature = "std", test))]
+use core::borrow::Borrow;
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+use core::{fmt, str};
+use num_traits::ToPrimitive;
+use oldtime::Duration as OldDuration;
+
+use div::div_mod_floor;
+#[cfg(any(feature = "alloc", feature = "std", test))]
+use format::DelayedFormat;
+use format::{parse, ParseError, ParseResult, Parsed, StrftimeItems};
+use format::{Item, Numeric, Pad};
+use naive::{IsoWeek, NaiveDateTime, NaiveTime};
+use {Datelike, Weekday};
+
+use super::internals::{self, DateImpl, Mdf, Of, YearFlags};
+use super::isoweek;
+
+const MAX_YEAR: i32 = internals::MAX_YEAR;
+const MIN_YEAR: i32 = internals::MIN_YEAR;
+
+//   MAX_YEAR-12-31 minus 0000-01-01
+// = ((MAX_YEAR+1)-01-01 minus 0001-01-01) + (0001-01-01 minus 0000-01-01) - 1 day
+// = ((MAX_YEAR+1)-01-01 minus 0001-01-01) + 365 days
+// = MAX_YEAR * 365 + (# of leap years from 0001 to MAX_YEAR) + 365 days
+#[cfg(test)] // only used for testing
+const MAX_DAYS_FROM_YEAR_0: i32 =
+    MAX_YEAR * 365 + MAX_YEAR / 4 - MAX_YEAR / 100 + MAX_YEAR / 400 + 365;
+
+//   MIN_YEAR-01-01 minus 0000-01-01
+// = (MIN_YEAR+400n+1)-01-01 minus (400n+1)-01-01
+// = ((MIN_YEAR+400n+1)-01-01 minus 0001-01-01) - ((400n+1)-01-01 minus 0001-01-01)
+// = ((MIN_YEAR+400n+1)-01-01 minus 0001-01-01) - 146097n days
+//
+// n is set to 1000 for convenience.
+#[cfg(test)] // only used for testing
+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;
+
+#[cfg(test)] // only used for testing, but duplicated in naive::datetime
+const MAX_BITS: usize = 44;
+
+/// ISO 8601 calendar date without timezone.
+/// Allows for every [proleptic Gregorian date](#calendar-date)
+/// from Jan 1, 262145 BCE to Dec 31, 262143 CE.
+/// Also supports the conversion from ISO 8601 ordinal and week date.
+///
+/// # Calendar Date
+///
+/// The ISO 8601 **calendar date** follows the proleptic Gregorian calendar.
+/// It is like a normal civil calendar but note some slight differences:
+///
+/// * Dates before the Gregorian calendar's inception in 1582 are defined via the extrapolation.
+///   Be careful, as historical dates are often noted in the Julian calendar and others
+///   and the transition to Gregorian may differ across countries (as late as early 20C).
+///
+///   (Some example: Both Shakespeare from Britain and Cervantes from Spain seemingly died
+///   on the same calendar date---April 23, 1616---but in the different calendar.
+///   Britain used the Julian calendar at that time, so Shakespeare's death is later.)
+///
+/// * ISO 8601 calendars has the year 0, which is 1 BCE (a year before 1 CE).
+///   If you need a typical BCE/BC and CE/AD notation for year numbers,
+///   use the [`Datelike::year_ce`](../trait.Datelike.html#method.year_ce) method.
+///
+/// # Week Date
+///
+/// The ISO 8601 **week date** is a triple of year number, week number
+/// and [day of the week](../enum.Weekday.html) with the following rules:
+///
+/// * A week consists of Monday through Sunday, and is always numbered within some year.
+///   The week number ranges from 1 to 52 or 53 depending on the year.
+///
+/// * The week 1 of given year is defined as the first week containing January 4 of that year,
+///   or equivalently, the first week containing four or more days in that year.
+///
+/// * The year number in the week date may *not* correspond to the actual Gregorian year.
+///   For example, January 3, 2016 (Sunday) was on the last (53rd) week of 2015.
+///
+/// Chrono's date types default to the ISO 8601 [calendar date](#calendar-date),
+/// but [`Datelike::iso_week`](../trait.Datelike.html#tymethod.iso_week) and
+/// [`Datelike::weekday`](../trait.Datelike.html#tymethod.weekday) methods
+/// can be used to get the corresponding week date.
+///
+/// # Ordinal Date
+///
+/// The ISO 8601 **ordinal date** is a pair of year number and day of the year ("ordinal").
+/// The ordinal number ranges from 1 to 365 or 366 depending on the year.
+/// The year number is the same as that of the [calendar date](#calendar-date).
+///
+/// This is currently the internal format of Chrono's date types.
+#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Copy, Clone)]
+pub struct NaiveDate {
+    ymdf: DateImpl, // (year << 13) | of
+}
+
+/// The minimum possible `NaiveDate` (January 1, 262145 BCE).
+pub const MIN_DATE: NaiveDate = NaiveDate { ymdf: (MIN_YEAR << 13) | (1 << 4) | 0o07 /*FE*/ };
+/// The maximum possible `NaiveDate` (December 31, 262143 CE).
+pub const MAX_DATE: NaiveDate = NaiveDate { ymdf: (MAX_YEAR << 13) | (365 << 4) | 0o17 /*F*/ };
+
+// as it is hard to verify year flags in `MIN_DATE` and `MAX_DATE`,
+// we use a separate run-time test.
+#[test]
+fn test_date_bounds() {
+    let calculated_min = NaiveDate::from_ymd(MIN_YEAR, 1, 1);
+    let calculated_max = NaiveDate::from_ymd(MAX_YEAR, 12, 31);
+    assert!(
+        MIN_DATE == calculated_min,
+        "`MIN_DATE` should have a year flag {:?}",
+        calculated_min.of().flags()
+    );
+    assert!(
+        MAX_DATE == calculated_max,
+        "`MAX_DATE` should have a year flag {:?}",
+        calculated_max.of().flags()
+    );
+
+    // let's also check that the entire range do not exceed 2^44 seconds
+    // (sometimes used for bounding `Duration` against overflow)
+    let maxsecs = MAX_DATE.signed_duration_since(MIN_DATE).num_seconds();
+    let maxsecs = maxsecs + 86401; // also take care of DateTime
+    assert!(
+        maxsecs < (1 << MAX_BITS),
+        "The entire `NaiveDate` range somehow exceeds 2^{} seconds",
+        MAX_BITS
+    );
+}
+
+impl NaiveDate {
+    /// Makes a new `NaiveDate` from year and packed ordinal-flags, with a verification.
+    fn from_of(year: i32, of: Of) -> Option<NaiveDate> {
+        if year >= MIN_YEAR && year <= MAX_YEAR && of.valid() {
+            let Of(of) = of;
+            Some(NaiveDate { ymdf: (year << 13) | (of as DateImpl) })
+        } else {
+            None
+        }
+    }
+
+    /// Makes a new `NaiveDate` from year and packed month-day-flags, with a verification.
+    fn from_mdf(year: i32, mdf: Mdf) -> Option<NaiveDate> {
+        NaiveDate::from_of(year, mdf.to_of())
+    }
+
+    /// Makes a new `NaiveDate` from the [calendar date](#calendar-date)
+    /// (year, month and day).
+    ///
+    /// Panics on the out-of-range date, invalid month and/or day.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 3, 14);
+    /// assert_eq!(d.year(), 2015);
+    /// assert_eq!(d.month(), 3);
+    /// assert_eq!(d.day(), 14);
+    /// assert_eq!(d.ordinal(), 73); // day of year
+    /// assert_eq!(d.iso_week().year(), 2015);
+    /// assert_eq!(d.iso_week().week(), 11);
+    /// assert_eq!(d.weekday(), Weekday::Sat);
+    /// assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
+    /// ~~~~
+    pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate {
+        NaiveDate::from_ymd_opt(year, month, day).expect("invalid or out-of-range date")
+    }
+
+    /// Makes a new `NaiveDate` from the [calendar date](#calendar-date)
+    /// (year, month and day).
+    ///
+    /// Returns `None` on the out-of-range date, invalid month and/or day.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let from_ymd_opt = NaiveDate::from_ymd_opt;
+    ///
+    /// assert!(from_ymd_opt(2015, 3, 14).is_some());
+    /// assert!(from_ymd_opt(2015, 0, 14).is_none());
+    /// assert!(from_ymd_opt(2015, 2, 29).is_none());
+    /// assert!(from_ymd_opt(-4, 2, 29).is_some()); // 5 BCE is a leap year
+    /// assert!(from_ymd_opt(400000, 1, 1).is_none());
+    /// assert!(from_ymd_opt(-400000, 1, 1).is_none());
+    /// ~~~~
+    pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate> {
+        let flags = YearFlags::from_year(year);
+        NaiveDate::from_mdf(year, Mdf::new(month, day, flags))
+    }
+
+    /// Makes a new `NaiveDate` from the [ordinal date](#ordinal-date)
+    /// (year and day of the year).
+    ///
+    /// Panics on the out-of-range date and/or invalid day of year.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_yo(2015, 73);
+    /// assert_eq!(d.ordinal(), 73);
+    /// assert_eq!(d.year(), 2015);
+    /// assert_eq!(d.month(), 3);
+    /// assert_eq!(d.day(), 14);
+    /// assert_eq!(d.iso_week().year(), 2015);
+    /// assert_eq!(d.iso_week().week(), 11);
+    /// assert_eq!(d.weekday(), Weekday::Sat);
+    /// assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
+    /// ~~~~
+    pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate {
+        NaiveDate::from_yo_opt(year, ordinal).expect("invalid or out-of-range date")
+    }
+
+    /// Makes a new `NaiveDate` from the [ordinal date](#ordinal-date)
+    /// (year and day of the year).
+    ///
+    /// Returns `None` on the out-of-range date and/or invalid day of year.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let from_yo_opt = NaiveDate::from_yo_opt;
+    ///
+    /// assert!(from_yo_opt(2015, 100).is_some());
+    /// assert!(from_yo_opt(2015, 0).is_none());
+    /// assert!(from_yo_opt(2015, 365).is_some());
+    /// assert!(from_yo_opt(2015, 366).is_none());
+    /// assert!(from_yo_opt(-4, 366).is_some()); // 5 BCE is a leap year
+    /// assert!(from_yo_opt(400000, 1).is_none());
+    /// assert!(from_yo_opt(-400000, 1).is_none());
+    /// ~~~~
+    pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate> {
+        let flags = YearFlags::from_year(year);
+        NaiveDate::from_of(year, Of::new(ordinal, flags))
+    }
+
+    /// Makes a new `NaiveDate` from the [ISO week date](#week-date)
+    /// (year, week number and day of the week).
+    /// The resulting `NaiveDate` may have a different year from the input year.
+    ///
+    /// Panics on the out-of-range date and/or invalid week number.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_isoywd(2015, 11, Weekday::Sat);
+    /// assert_eq!(d.iso_week().year(), 2015);
+    /// assert_eq!(d.iso_week().week(), 11);
+    /// assert_eq!(d.weekday(), Weekday::Sat);
+    /// assert_eq!(d.year(), 2015);
+    /// assert_eq!(d.month(), 3);
+    /// assert_eq!(d.day(), 14);
+    /// assert_eq!(d.ordinal(), 73); // day of year
+    /// assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
+    /// ~~~~
+    pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate {
+        NaiveDate::from_isoywd_opt(year, week, weekday).expect("invalid or out-of-range date")
+    }
+
+    /// Makes a new `NaiveDate` from the [ISO week date](#week-date)
+    /// (year, week number and day of the week).
+    /// The resulting `NaiveDate` may have a different year from the input year.
+    ///
+    /// Returns `None` on the out-of-range date and/or invalid week number.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Weekday};
+    ///
+    /// let from_ymd = NaiveDate::from_ymd;
+    /// let from_isoywd_opt = NaiveDate::from_isoywd_opt;
+    ///
+    /// assert_eq!(from_isoywd_opt(2015, 0, Weekday::Sun), None);
+    /// assert_eq!(from_isoywd_opt(2015, 10, Weekday::Sun), Some(from_ymd(2015, 3, 8)));
+    /// assert_eq!(from_isoywd_opt(2015, 30, Weekday::Mon), Some(from_ymd(2015, 7, 20)));
+    /// assert_eq!(from_isoywd_opt(2015, 60, Weekday::Mon), None);
+    ///
+    /// assert_eq!(from_isoywd_opt(400000, 10, Weekday::Fri), None);
+    /// assert_eq!(from_isoywd_opt(-400000, 10, Weekday::Sat), None);
+    /// ~~~~
+    ///
+    /// The year number of ISO week date may differ from that of the calendar date.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveDate, Weekday};
+    /// # let from_ymd = NaiveDate::from_ymd;
+    /// # let from_isoywd_opt = NaiveDate::from_isoywd_opt;
+    /// //           Mo Tu We Th Fr Sa Su
+    /// // 2014-W52  22 23 24 25 26 27 28    has 4+ days of new year,
+    /// // 2015-W01  29 30 31  1  2  3  4 <- so this is the first week
+    /// assert_eq!(from_isoywd_opt(2014, 52, Weekday::Sun), Some(from_ymd(2014, 12, 28)));
+    /// assert_eq!(from_isoywd_opt(2014, 53, Weekday::Mon), None);
+    /// assert_eq!(from_isoywd_opt(2015, 1, Weekday::Mon), Some(from_ymd(2014, 12, 29)));
+    ///
+    /// // 2015-W52  21 22 23 24 25 26 27    has 4+ days of old year,
+    /// // 2015-W53  28 29 30 31  1  2  3 <- so this is the last week
+    /// // 2016-W01   4  5  6  7  8  9 10
+    /// assert_eq!(from_isoywd_opt(2015, 52, Weekday::Sun), Some(from_ymd(2015, 12, 27)));
+    /// assert_eq!(from_isoywd_opt(2015, 53, Weekday::Sun), Some(from_ymd(2016, 1, 3)));
+    /// assert_eq!(from_isoywd_opt(2015, 54, Weekday::Mon), None);
+    /// assert_eq!(from_isoywd_opt(2016, 1, Weekday::Mon), Some(from_ymd(2016, 1, 4)));
+    /// ~~~~
+    pub fn from_isoywd_opt(year: i32, week: u32, weekday: Weekday) -> Option<NaiveDate> {
+        let flags = YearFlags::from_year(year);
+        let nweeks = flags.nisoweeks();
+        if 1 <= week && week <= nweeks {
+            // ordinal = week ordinal - delta
+            let weekord = week * 7 + weekday as u32;
+            let delta = flags.isoweek_delta();
+            if weekord <= delta {
+                // ordinal < 1, previous year
+                let prevflags = YearFlags::from_year(year - 1);
+                NaiveDate::from_of(
+                    year - 1,
+                    Of::new(weekord + prevflags.ndays() - delta, prevflags),
+                )
+            } else {
+                let ordinal = weekord - delta;
+                let ndays = flags.ndays();
+                if ordinal <= ndays {
+                    // this year
+                    NaiveDate::from_of(year, Of::new(ordinal, flags))
+                } else {
+                    // ordinal > ndays, next year
+                    let nextflags = YearFlags::from_year(year + 1);
+                    NaiveDate::from_of(year + 1, Of::new(ordinal - ndays, nextflags))
+                }
+            }
+        } else {
+            None
+        }
+    }
+
+    /// Makes a new `NaiveDate` from a day's number in the proleptic Gregorian calendar, with
+    /// January 1, 1 being day 1.
+    ///
+    /// Panics if the date is out of range.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_num_days_from_ce(735671);
+    /// assert_eq!(d.num_days_from_ce(), 735671); // days since January 1, 1 CE
+    /// assert_eq!(d.year(), 2015);
+    /// assert_eq!(d.month(), 3);
+    /// assert_eq!(d.day(), 14);
+    /// assert_eq!(d.ordinal(), 73); // day of year
+    /// assert_eq!(d.iso_week().year(), 2015);
+    /// assert_eq!(d.iso_week().week(), 11);
+    /// assert_eq!(d.weekday(), Weekday::Sat);
+    /// ~~~~
+    ///
+    /// While not directly supported by Chrono,
+    /// it is easy to convert from the Julian day number
+    /// (January 1, 4713 BCE in the *Julian* calendar being Day 0)
+    /// to Gregorian with this method.
+    /// (Note that this panics when `jd` is out of range.)
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// fn jd_to_date(jd: i32) -> NaiveDate {
+    ///     // keep in mind that the Julian day number is 0-based
+    ///     // while this method requires an 1-based number.
+    ///     NaiveDate::from_num_days_from_ce(jd - 1721425)
+    /// }
+    ///
+    /// // January 1, 4713 BCE in Julian = November 24, 4714 BCE in Gregorian
+    /// assert_eq!(jd_to_date(0), NaiveDate::from_ymd(-4713, 11, 24));
+    ///
+    /// assert_eq!(jd_to_date(1721426), NaiveDate::from_ymd(1, 1, 1));
+    /// assert_eq!(jd_to_date(2450000), NaiveDate::from_ymd(1995, 10, 9));
+    /// assert_eq!(jd_to_date(2451545), NaiveDate::from_ymd(2000, 1, 1));
+    /// ~~~~
+    #[inline]
+    pub fn from_num_days_from_ce(days: i32) -> NaiveDate {
+        NaiveDate::from_num_days_from_ce_opt(days).expect("out-of-range date")
+    }
+
+    /// Makes a new `NaiveDate` from a day's number in the proleptic Gregorian calendar, with
+    /// January 1, 1 being day 1.
+    ///
+    /// Returns `None` if the date is out of range.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let from_ndays_opt = NaiveDate::from_num_days_from_ce_opt;
+    /// let from_ymd = NaiveDate::from_ymd;
+    ///
+    /// assert_eq!(from_ndays_opt(730_000),      Some(from_ymd(1999, 9, 3)));
+    /// assert_eq!(from_ndays_opt(1),            Some(from_ymd(1, 1, 1)));
+    /// assert_eq!(from_ndays_opt(0),            Some(from_ymd(0, 12, 31)));
+    /// assert_eq!(from_ndays_opt(-1),           Some(from_ymd(0, 12, 30)));
+    /// assert_eq!(from_ndays_opt(100_000_000),  None);
+    /// assert_eq!(from_ndays_opt(-100_000_000), None);
+    /// ~~~~
+    pub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate> {
+        let days = days + 365; // make December 31, 1 BCE equal to day 0
+        let (year_div_400, cycle) = div_mod_floor(days, 146_097);
+        let (year_mod_400, ordinal) = internals::cycle_to_yo(cycle as u32);
+        let flags = YearFlags::from_year_mod_400(year_mod_400 as i32);
+        NaiveDate::from_of(year_div_400 * 400 + year_mod_400 as i32, Of::new(ordinal, flags))
+    }
+
+    /// Makes a new `NaiveDate` by counting the number of occurrences of a particular day-of-week
+    /// since the beginning of the given month.  For instance, if you want the 2nd Friday of March
+    /// 2017, you would use `NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2)`.
+    ///
+    /// # Panics
+    ///
+    /// The resulting `NaiveDate` is guaranteed to be in `month`.  If `n` is larger than the number
+    /// of `weekday` in `month` (eg. the 6th Friday of March 2017) then this function will panic.
+    ///
+    /// `n` is 1-indexed.  Passing `n=0` will cause a panic.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Weekday};
+    ///
+    /// let from_weekday_of_month = NaiveDate::from_weekday_of_month;
+    /// let from_ymd = NaiveDate::from_ymd;
+    ///
+    /// assert_eq!(from_weekday_of_month(2018, 8, Weekday::Wed, 1), from_ymd(2018, 8, 1));
+    /// assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 1), from_ymd(2018, 8, 3));
+    /// assert_eq!(from_weekday_of_month(2018, 8, Weekday::Tue, 2), from_ymd(2018, 8, 14));
+    /// assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 4), from_ymd(2018, 8, 24));
+    /// assert_eq!(from_weekday_of_month(2018, 8, Weekday::Fri, 5), from_ymd(2018, 8, 31));
+    /// ~~~~
+    pub fn from_weekday_of_month(year: i32, month: u32, weekday: Weekday, n: u8) -> NaiveDate {
+        NaiveDate::from_weekday_of_month_opt(year, month, weekday, n).expect("out-of-range date")
+    }
+
+    /// Makes a new `NaiveDate` by counting the number of occurrences of a particular day-of-week
+    /// since the beginning of the given month.  For instance, if you want the 2nd Friday of March
+    /// 2017, you would use `NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2)`.  `n` is 1-indexed.
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Weekday};
+    /// assert_eq!(NaiveDate::from_weekday_of_month_opt(2017, 3, Weekday::Fri, 2),
+    ///            NaiveDate::from_ymd_opt(2017, 3, 10))
+    /// ~~~~
+    ///
+    /// Returns `None` if `n` out-of-range; ie. if `n` is larger than the number of `weekday` in
+    /// `month` (eg. the 6th Friday of March 2017), or if `n == 0`.
+    pub fn from_weekday_of_month_opt(
+        year: i32,
+        month: u32,
+        weekday: Weekday,
+        n: u8,
+    ) -> Option<NaiveDate> {
+        if n == 0 {
+            return None;
+        }
+        let first = NaiveDate::from_ymd(year, month, 1).weekday();
+        let first_to_dow = (7 + weekday.number_from_monday() - first.number_from_monday()) % 7;
+        let day = (u32::from(n) - 1) * 7 + first_to_dow + 1;
+        NaiveDate::from_ymd_opt(year, month, day)
+    }
+
+    /// Parses a string with the specified format string and returns a new `NaiveDate`.
+    /// See the [`format::strftime` module](../format/strftime/index.html)
+    /// on the supported escape sequences.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let parse_from_str = NaiveDate::parse_from_str;
+    ///
+    /// assert_eq!(parse_from_str("2015-09-05", "%Y-%m-%d"),
+    ///            Ok(NaiveDate::from_ymd(2015, 9, 5)));
+    /// assert_eq!(parse_from_str("5sep2015", "%d%b%Y"),
+    ///            Ok(NaiveDate::from_ymd(2015, 9, 5)));
+    /// ~~~~
+    ///
+    /// Time and offset is ignored for the purpose of parsing.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # let parse_from_str = NaiveDate::parse_from_str;
+    /// assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
+    ///            Ok(NaiveDate::from_ymd(2014, 5, 17)));
+    /// ~~~~
+    ///
+    /// Out-of-bound dates or insufficient fields are errors.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # let parse_from_str = NaiveDate::parse_from_str;
+    /// assert!(parse_from_str("2015/9", "%Y/%m").is_err());
+    /// assert!(parse_from_str("2015/9/31", "%Y/%m/%d").is_err());
+    /// ~~~~
+    ///
+    /// All parsed fields should be consistent to each other, otherwise it's an error.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # let parse_from_str = NaiveDate::parse_from_str;
+    /// assert!(parse_from_str("Sat, 09 Aug 2013", "%a, %d %b %Y").is_err());
+    /// ~~~~
+    pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDate> {
+        let mut parsed = Parsed::new();
+        parse(&mut parsed, s, StrftimeItems::new(fmt))?;
+        parsed.to_naive_date()
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date and given `NaiveTime`.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveTime, NaiveDateTime};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    /// let t = NaiveTime::from_hms_milli(12, 34, 56, 789);
+    ///
+    /// let dt: NaiveDateTime = d.and_time(t);
+    /// assert_eq!(dt.date(), d);
+    /// assert_eq!(dt.time(), t);
+    /// ~~~~
+    #[inline]
+    pub fn and_time(&self, time: NaiveTime) -> NaiveDateTime {
+        NaiveDateTime::new(*self, time)
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute and second.
+    ///
+    /// No [leap second](./struct.NaiveTime.html#leap-second-handling) is allowed here;
+    /// use `NaiveDate::and_hms_*` methods with a subsecond parameter instead.
+    ///
+    /// Panics on invalid hour, minute and/or second.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    ///
+    /// let dt: NaiveDateTime = d.and_hms(12, 34, 56);
+    /// assert_eq!(dt.year(), 2015);
+    /// assert_eq!(dt.weekday(), Weekday::Wed);
+    /// assert_eq!(dt.second(), 56);
+    /// ~~~~
+    #[inline]
+    pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime {
+        self.and_hms_opt(hour, min, sec).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute and second.
+    ///
+    /// No [leap second](./struct.NaiveTime.html#leap-second-handling) is allowed here;
+    /// use `NaiveDate::and_hms_*_opt` methods with a subsecond parameter instead.
+    ///
+    /// Returns `None` on invalid hour, minute and/or second.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    /// assert!(d.and_hms_opt(12, 34, 56).is_some());
+    /// assert!(d.and_hms_opt(12, 34, 60).is_none()); // use `and_hms_milli_opt` instead
+    /// assert!(d.and_hms_opt(12, 60, 56).is_none());
+    /// assert!(d.and_hms_opt(24, 34, 56).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_opt(&self, hour: u32, min: u32, sec: u32) -> Option<NaiveDateTime> {
+        NaiveTime::from_hms_opt(hour, min, sec).map(|time| self.and_time(time))
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and millisecond.
+    ///
+    /// The millisecond part can exceed 1,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// Panics on invalid hour, minute, second and/or millisecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    ///
+    /// let dt: NaiveDateTime = d.and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.year(), 2015);
+    /// assert_eq!(dt.weekday(), Weekday::Wed);
+    /// assert_eq!(dt.second(), 56);
+    /// assert_eq!(dt.nanosecond(), 789_000_000);
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_milli(&self, hour: u32, min: u32, sec: u32, milli: u32) -> NaiveDateTime {
+        self.and_hms_milli_opt(hour, min, sec, milli).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and millisecond.
+    ///
+    /// The millisecond part can exceed 1,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// Returns `None` on invalid hour, minute, second and/or millisecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    /// assert!(d.and_hms_milli_opt(12, 34, 56,   789).is_some());
+    /// assert!(d.and_hms_milli_opt(12, 34, 59, 1_789).is_some()); // leap second
+    /// assert!(d.and_hms_milli_opt(12, 34, 59, 2_789).is_none());
+    /// assert!(d.and_hms_milli_opt(12, 34, 60,   789).is_none());
+    /// assert!(d.and_hms_milli_opt(12, 60, 56,   789).is_none());
+    /// assert!(d.and_hms_milli_opt(24, 34, 56,   789).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_milli_opt(
+        &self,
+        hour: u32,
+        min: u32,
+        sec: u32,
+        milli: u32,
+    ) -> Option<NaiveDateTime> {
+        NaiveTime::from_hms_milli_opt(hour, min, sec, milli).map(|time| self.and_time(time))
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and microsecond.
+    ///
+    /// The microsecond part can exceed 1,000,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// Panics on invalid hour, minute, second and/or microsecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    ///
+    /// let dt: NaiveDateTime = d.and_hms_micro(12, 34, 56, 789_012);
+    /// assert_eq!(dt.year(), 2015);
+    /// assert_eq!(dt.weekday(), Weekday::Wed);
+    /// assert_eq!(dt.second(), 56);
+    /// assert_eq!(dt.nanosecond(), 789_012_000);
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_micro(&self, hour: u32, min: u32, sec: u32, micro: u32) -> NaiveDateTime {
+        self.and_hms_micro_opt(hour, min, sec, micro).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and microsecond.
+    ///
+    /// The microsecond part can exceed 1,000,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// Returns `None` on invalid hour, minute, second and/or microsecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    /// assert!(d.and_hms_micro_opt(12, 34, 56,   789_012).is_some());
+    /// assert!(d.and_hms_micro_opt(12, 34, 59, 1_789_012).is_some()); // leap second
+    /// assert!(d.and_hms_micro_opt(12, 34, 59, 2_789_012).is_none());
+    /// assert!(d.and_hms_micro_opt(12, 34, 60,   789_012).is_none());
+    /// assert!(d.and_hms_micro_opt(12, 60, 56,   789_012).is_none());
+    /// assert!(d.and_hms_micro_opt(24, 34, 56,   789_012).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_micro_opt(
+        &self,
+        hour: u32,
+        min: u32,
+        sec: u32,
+        micro: u32,
+    ) -> Option<NaiveDateTime> {
+        NaiveTime::from_hms_micro_opt(hour, min, sec, micro).map(|time| self.and_time(time))
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and nanosecond.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// Panics on invalid hour, minute, second and/or nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    ///
+    /// let dt: NaiveDateTime = d.and_hms_nano(12, 34, 56, 789_012_345);
+    /// assert_eq!(dt.year(), 2015);
+    /// assert_eq!(dt.weekday(), Weekday::Wed);
+    /// assert_eq!(dt.second(), 56);
+    /// assert_eq!(dt.nanosecond(), 789_012_345);
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_nano(&self, hour: u32, min: u32, sec: u32, nano: u32) -> NaiveDateTime {
+        self.and_hms_nano_opt(hour, min, sec, nano).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveDateTime` from the current date, hour, minute, second and nanosecond.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// Returns `None` on invalid hour, minute, second and/or nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    /// assert!(d.and_hms_nano_opt(12, 34, 56,   789_012_345).is_some());
+    /// assert!(d.and_hms_nano_opt(12, 34, 59, 1_789_012_345).is_some()); // leap second
+    /// assert!(d.and_hms_nano_opt(12, 34, 59, 2_789_012_345).is_none());
+    /// assert!(d.and_hms_nano_opt(12, 34, 60,   789_012_345).is_none());
+    /// assert!(d.and_hms_nano_opt(12, 60, 56,   789_012_345).is_none());
+    /// assert!(d.and_hms_nano_opt(24, 34, 56,   789_012_345).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn and_hms_nano_opt(
+        &self,
+        hour: u32,
+        min: u32,
+        sec: u32,
+        nano: u32,
+    ) -> Option<NaiveDateTime> {
+        NaiveTime::from_hms_nano_opt(hour, min, sec, nano).map(|time| self.and_time(time))
+    }
+
+    /// Returns the packed month-day-flags.
+    #[inline]
+    fn mdf(&self) -> Mdf {
+        self.of().to_mdf()
+    }
+
+    /// Returns the packed ordinal-flags.
+    #[inline]
+    fn of(&self) -> Of {
+        Of((self.ymdf & 0b1_1111_1111_1111) as u32)
+    }
+
+    /// Makes a new `NaiveDate` with the packed month-day-flags changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    #[inline]
+    fn with_mdf(&self, mdf: Mdf) -> Option<NaiveDate> {
+        self.with_of(mdf.to_of())
+    }
+
+    /// Makes a new `NaiveDate` with the packed ordinal-flags changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    #[inline]
+    fn with_of(&self, of: Of) -> Option<NaiveDate> {
+        if of.valid() {
+            let Of(of) = of;
+            Some(NaiveDate { ymdf: (self.ymdf & !0b1_1111_1111_1111) | of as DateImpl })
+        } else {
+            None
+        }
+    }
+
+    /// Makes a new `NaiveDate` for the next calendar date.
+    ///
+    /// Panics when `self` is the last representable date.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015,  6,  3).succ(), NaiveDate::from_ymd(2015, 6, 4));
+    /// assert_eq!(NaiveDate::from_ymd(2015,  6, 30).succ(), NaiveDate::from_ymd(2015, 7, 1));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 12, 31).succ(), NaiveDate::from_ymd(2016, 1, 1));
+    /// ~~~~
+    #[inline]
+    pub fn succ(&self) -> NaiveDate {
+        self.succ_opt().expect("out of bound")
+    }
+
+    /// Makes a new `NaiveDate` for the next calendar date.
+    ///
+    /// Returns `None` when `self` is the last representable date.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    /// use chrono::naive::MAX_DATE;
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 6, 3).succ_opt(),
+    ///            Some(NaiveDate::from_ymd(2015, 6, 4)));
+    /// assert_eq!(MAX_DATE.succ_opt(), None);
+    /// ~~~~
+    #[inline]
+    pub fn succ_opt(&self) -> Option<NaiveDate> {
+        self.with_of(self.of().succ()).or_else(|| NaiveDate::from_ymd_opt(self.year() + 1, 1, 1))
+    }
+
+    /// Makes a new `NaiveDate` for the previous calendar date.
+    ///
+    /// Panics when `self` is the first representable date.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred(), NaiveDate::from_ymd(2015,  6,  2));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 6, 1).pred(), NaiveDate::from_ymd(2015,  5, 31));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 1, 1).pred(), NaiveDate::from_ymd(2014, 12, 31));
+    /// ~~~~
+    #[inline]
+    pub fn pred(&self) -> NaiveDate {
+        self.pred_opt().expect("out of bound")
+    }
+
+    /// Makes a new `NaiveDate` for the previous calendar date.
+    ///
+    /// Returns `None` when `self` is the first representable date.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    /// use chrono::naive::MIN_DATE;
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 6, 3).pred_opt(),
+    ///            Some(NaiveDate::from_ymd(2015, 6, 2)));
+    /// assert_eq!(MIN_DATE.pred_opt(), None);
+    /// ~~~~
+    #[inline]
+    pub fn pred_opt(&self) -> Option<NaiveDate> {
+        self.with_of(self.of().pred()).or_else(|| NaiveDate::from_ymd_opt(self.year() - 1, 12, 31))
+    }
+
+    /// Adds the `days` part of given `Duration` to the current date.
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveDate};
+    /// use chrono::naive::MAX_DATE;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 9, 5);
+    /// assert_eq!(d.checked_add_signed(Duration::days(40)),
+    ///            Some(NaiveDate::from_ymd(2015, 10, 15)));
+    /// assert_eq!(d.checked_add_signed(Duration::days(-40)),
+    ///            Some(NaiveDate::from_ymd(2015, 7, 27)));
+    /// assert_eq!(d.checked_add_signed(Duration::days(1_000_000_000)), None);
+    /// assert_eq!(d.checked_add_signed(Duration::days(-1_000_000_000)), None);
+    /// assert_eq!(MAX_DATE.checked_add_signed(Duration::days(1)), None);
+    /// # }
+    /// ~~~~
+    pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDate> {
+        let year = self.year();
+        let (mut year_div_400, year_mod_400) = div_mod_floor(year, 400);
+        let cycle = internals::yo_to_cycle(year_mod_400 as u32, self.of().ordinal());
+        let cycle = try_opt!((cycle as i32).checked_add(try_opt!(rhs.num_days().to_i32())));
+        let (cycle_div_400y, cycle) = div_mod_floor(cycle, 146_097);
+        year_div_400 += cycle_div_400y;
+
+        let (year_mod_400, ordinal) = internals::cycle_to_yo(cycle as u32);
+        let flags = YearFlags::from_year_mod_400(year_mod_400 as i32);
+        NaiveDate::from_of(year_div_400 * 400 + year_mod_400 as i32, Of::new(ordinal, flags))
+    }
+
+    /// Subtracts the `days` part of given `Duration` from the current date.
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveDate};
+    /// use chrono::naive::MIN_DATE;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 9, 5);
+    /// assert_eq!(d.checked_sub_signed(Duration::days(40)),
+    ///            Some(NaiveDate::from_ymd(2015, 7, 27)));
+    /// assert_eq!(d.checked_sub_signed(Duration::days(-40)),
+    ///            Some(NaiveDate::from_ymd(2015, 10, 15)));
+    /// assert_eq!(d.checked_sub_signed(Duration::days(1_000_000_000)), None);
+    /// assert_eq!(d.checked_sub_signed(Duration::days(-1_000_000_000)), None);
+    /// assert_eq!(MIN_DATE.checked_sub_signed(Duration::days(1)), None);
+    /// # }
+    /// ~~~~
+    pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDate> {
+        let year = self.year();
+        let (mut year_div_400, year_mod_400) = div_mod_floor(year, 400);
+        let cycle = internals::yo_to_cycle(year_mod_400 as u32, self.of().ordinal());
+        let cycle = try_opt!((cycle as i32).checked_sub(try_opt!(rhs.num_days().to_i32())));
+        let (cycle_div_400y, cycle) = div_mod_floor(cycle, 146_097);
+        year_div_400 += cycle_div_400y;
+
+        let (year_mod_400, ordinal) = internals::cycle_to_yo(cycle as u32);
+        let flags = YearFlags::from_year_mod_400(year_mod_400 as i32);
+        NaiveDate::from_of(year_div_400 * 400 + year_mod_400 as i32, Of::new(ordinal, flags))
+    }
+
+    /// Subtracts another `NaiveDate` from the current date.
+    /// Returns a `Duration` of integral numbers.
+    ///
+    /// This does not overflow or underflow at all,
+    /// as all possible output fits in the range of `Duration`.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveDate};
+    ///
+    /// let from_ymd = NaiveDate::from_ymd;
+    /// let since = NaiveDate::signed_duration_since;
+    ///
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 1)), Duration::zero());
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 12, 31)), Duration::days(1));
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 2)), Duration::days(-1));
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 9, 23)), Duration::days(100));
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 1, 1)), Duration::days(365));
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2010, 1, 1)), Duration::days(365*4 + 1));
+    /// assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(1614, 1, 1)), Duration::days(365*400 + 97));
+    /// # }
+    /// ~~~~
+    pub fn signed_duration_since(self, rhs: NaiveDate) -> OldDuration {
+        let year1 = self.year();
+        let year2 = rhs.year();
+        let (year1_div_400, year1_mod_400) = div_mod_floor(year1, 400);
+        let (year2_div_400, year2_mod_400) = div_mod_floor(year2, 400);
+        let cycle1 = i64::from(internals::yo_to_cycle(year1_mod_400 as u32, self.of().ordinal()));
+        let cycle2 = i64::from(internals::yo_to_cycle(year2_mod_400 as u32, rhs.of().ordinal()));
+        OldDuration::days(
+            (i64::from(year1_div_400) - i64::from(year2_div_400)) * 146_097 + (cycle1 - cycle2),
+        )
+    }
+
+    /// Formats the date with the specified formatting items.
+    /// Otherwise it is the same as the ordinary `format` method.
+    ///
+    /// The `Iterator` of items should be `Clone`able,
+    /// since the resulting `DelayedFormat` value may be formatted multiple times.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    /// use chrono::format::strftime::StrftimeItems;
+    ///
+    /// let fmt = StrftimeItems::new("%Y-%m-%d");
+    /// let d = NaiveDate::from_ymd(2015, 9, 5);
+    /// assert_eq!(d.format_with_items(fmt.clone()).to_string(), "2015-09-05");
+    /// assert_eq!(d.format("%Y-%m-%d").to_string(),             "2015-09-05");
+    /// ~~~~
+    ///
+    /// The resulting `DelayedFormat` can be formatted directly via the `Display` trait.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # use chrono::format::strftime::StrftimeItems;
+    /// # let fmt = StrftimeItems::new("%Y-%m-%d").clone();
+    /// # let d = NaiveDate::from_ymd(2015, 9, 5);
+    /// assert_eq!(format!("{}", d.format_with_items(fmt)), "2015-09-05");
+    /// ~~~~
+    #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
+    pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
+    where
+        I: Iterator<Item = B> + Clone,
+        B: Borrow<Item<'a>>,
+    {
+        DelayedFormat::new(Some(*self), None, items)
+    }
+
+    /// Formats the date with the specified format string.
+    /// See the [`format::strftime` module](../format/strftime/index.html)
+    /// on the supported escape sequences.
+    ///
+    /// This returns a `DelayedFormat`,
+    /// which gets converted to a string only when actual formatting happens.
+    /// You may use the `to_string` method to get a `String`,
+    /// or just feed it into `print!` and other formatting macros.
+    /// (In this way it avoids the redundant memory allocation.)
+    ///
+    /// A wrong format string does *not* issue an error immediately.
+    /// Rather, converting or formatting the `DelayedFormat` fails.
+    /// You are recommended to immediately use `DelayedFormat` for this reason.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 9, 5);
+    /// assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");
+    /// assert_eq!(d.format("%A, %-d %B, %C%y").to_string(), "Saturday, 5 September, 2015");
+    /// ~~~~
+    ///
+    /// The resulting `DelayedFormat` can be formatted directly via the `Display` trait.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # let d = NaiveDate::from_ymd(2015, 9, 5);
+    /// assert_eq!(format!("{}", d.format("%Y-%m-%d")), "2015-09-05");
+    /// assert_eq!(format!("{}", d.format("%A, %-d %B, %C%y")), "Saturday, 5 September, 2015");
+    /// ~~~~
+    #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
+    pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
+        self.format_with_items(StrftimeItems::new(fmt))
+    }
+
+    /// Returns an iterator that steps by days until the last representable date.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use chrono::NaiveDate;
+    ///
+    /// let expected = [
+    ///     NaiveDate::from_ymd(2016, 2, 27),
+    ///     NaiveDate::from_ymd(2016, 2, 28),
+    ///     NaiveDate::from_ymd(2016, 2, 29),
+    ///     NaiveDate::from_ymd(2016, 3, 1),
+    /// ];
+    ///
+    /// let mut count = 0;
+    /// for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_days().take(4).enumerate() {
+    ///    assert_eq!(d, expected[idx]);
+    ///    count += 1;
+    /// }
+    /// assert_eq!(count, 4);
+    /// ```
+    #[inline]
+    pub fn iter_days(&self) -> NaiveDateDaysIterator {
+        NaiveDateDaysIterator { value: *self }
+    }
+
+    /// Returns an iterator that steps by weeks until the last representable date.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use chrono::NaiveDate;
+    ///
+    /// let expected = [
+    ///     NaiveDate::from_ymd(2016, 2, 27),
+    ///     NaiveDate::from_ymd(2016, 3, 5),
+    ///     NaiveDate::from_ymd(2016, 3, 12),
+    ///     NaiveDate::from_ymd(2016, 3, 19),
+    /// ];
+    ///
+    /// let mut count = 0;
+    /// for (idx, d) in NaiveDate::from_ymd(2016, 2, 27).iter_weeks().take(4).enumerate() {
+    ///    assert_eq!(d, expected[idx]);
+    ///    count += 1;
+    /// }
+    /// assert_eq!(count, 4);
+    /// ```
+    #[inline]
+    pub fn iter_weeks(&self) -> NaiveDateWeeksIterator {
+        NaiveDateWeeksIterator { value: *self }
+    }
+}
+
+impl Datelike for NaiveDate {
+    /// Returns the year number in the [calendar date](#calendar-date).
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).year(), 2015);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).year(), -308); // 309 BCE
+    /// ~~~~
+    #[inline]
+    fn year(&self) -> i32 {
+        self.ymdf >> 13
+    }
+
+    /// Returns the month number starting from 1.
+    ///
+    /// The return value ranges from 1 to 12.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month(), 9);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month(), 3);
+    /// ~~~~
+    #[inline]
+    fn month(&self) -> u32 {
+        self.mdf().month()
+    }
+
+    /// Returns the month number starting from 0.
+    ///
+    /// The return value ranges from 0 to 11.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).month0(), 8);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).month0(), 2);
+    /// ~~~~
+    #[inline]
+    fn month0(&self) -> u32 {
+        self.mdf().month() - 1
+    }
+
+    /// Returns the day of month starting from 1.
+    ///
+    /// The return value ranges from 1 to 31. (The last day of month differs by months.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day(), 8);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day(), 14);
+    /// ~~~~
+    ///
+    /// Combined with [`NaiveDate::pred`](#method.pred),
+    /// one can determine the number of days in a particular month.
+    /// (Note that this panics when `year` is out of range.)
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// fn ndays_in_month(year: i32, month: u32) -> u32 {
+    ///     // the first day of the next month...
+    ///     let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) };
+    ///     let d = NaiveDate::from_ymd(y, m, 1);
+    ///
+    ///     // ...is preceded by the last day of the original month
+    ///     d.pred().day()
+    /// }
+    ///
+    /// assert_eq!(ndays_in_month(2015, 8), 31);
+    /// assert_eq!(ndays_in_month(2015, 9), 30);
+    /// assert_eq!(ndays_in_month(2015, 12), 31);
+    /// assert_eq!(ndays_in_month(2016, 2), 29);
+    /// assert_eq!(ndays_in_month(2017, 2), 28);
+    /// ~~~~
+    #[inline]
+    fn day(&self) -> u32 {
+        self.mdf().day()
+    }
+
+    /// Returns the day of month starting from 0.
+    ///
+    /// The return value ranges from 0 to 30. (The last day of month differs by months.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).day0(), 7);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).day0(), 13);
+    /// ~~~~
+    #[inline]
+    fn day0(&self) -> u32 {
+        self.mdf().day() - 1
+    }
+
+    /// Returns the day of year starting from 1.
+    ///
+    /// The return value ranges from 1 to 366. (The last day of year differs by years.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal(), 251);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal(), 74);
+    /// ~~~~
+    ///
+    /// Combined with [`NaiveDate::pred`](#method.pred),
+    /// one can determine the number of days in a particular year.
+    /// (Note that this panics when `year` is out of range.)
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// fn ndays_in_year(year: i32) -> u32 {
+    ///     // the first day of the next year...
+    ///     let d = NaiveDate::from_ymd(year + 1, 1, 1);
+    ///
+    ///     // ...is preceded by the last day of the original year
+    ///     d.pred().ordinal()
+    /// }
+    ///
+    /// assert_eq!(ndays_in_year(2015), 365);
+    /// assert_eq!(ndays_in_year(2016), 366);
+    /// assert_eq!(ndays_in_year(2017), 365);
+    /// assert_eq!(ndays_in_year(2000), 366);
+    /// assert_eq!(ndays_in_year(2100), 365);
+    /// ~~~~
+    #[inline]
+    fn ordinal(&self) -> u32 {
+        self.of().ordinal()
+    }
+
+    /// Returns the day of year starting from 0.
+    ///
+    /// The return value ranges from 0 to 365. (The last day of year differs by years.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).ordinal0(), 250);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).ordinal0(), 73);
+    /// ~~~~
+    #[inline]
+    fn ordinal0(&self) -> u32 {
+        self.of().ordinal() - 1
+    }
+
+    /// Returns the day of week.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).weekday(), Weekday::Tue);
+    /// assert_eq!(NaiveDate::from_ymd(-308, 3, 14).weekday(), Weekday::Fri);
+    /// ~~~~
+    #[inline]
+    fn weekday(&self) -> Weekday {
+        self.of().weekday()
+    }
+
+    #[inline]
+    fn iso_week(&self) -> IsoWeek {
+        isoweek::iso_week_from_yof(self.year(), self.of())
+    }
+
+    /// Makes a new `NaiveDate` with the year number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(2016),
+    ///            Some(NaiveDate::from_ymd(2016, 9, 8)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_year(-308),
+    ///            Some(NaiveDate::from_ymd(-308, 9, 8)));
+    /// ~~~~
+    ///
+    /// A leap day (February 29) is a good example that this method can return `None`.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveDate, Datelike};
+    /// assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2015).is_none());
+    /// assert!(NaiveDate::from_ymd(2016, 2, 29).with_year(2020).is_some());
+    /// ~~~~
+    #[inline]
+    fn with_year(&self, year: i32) -> Option<NaiveDate> {
+        // we need to operate with `mdf` since we should keep the month and day number as is
+        let mdf = self.mdf();
+
+        // adjust the flags as needed
+        let flags = YearFlags::from_year(year);
+        let mdf = mdf.with_flags(flags);
+
+        NaiveDate::from_mdf(year, mdf)
+    }
+
+    /// Makes a new `NaiveDate` with the month number (starting from 1) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(10),
+    ///            Some(NaiveDate::from_ymd(2015, 10, 8)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month(13), None); // no month 13
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month(2), None); // no February 30
+    /// ~~~~
+    #[inline]
+    fn with_month(&self, month: u32) -> Option<NaiveDate> {
+        self.with_mdf(self.mdf().with_month(month))
+    }
+
+    /// Makes a new `NaiveDate` with the month number (starting from 0) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(9),
+    ///            Some(NaiveDate::from_ymd(2015, 10, 8)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_month0(12), None); // no month 13
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 30).with_month0(1), None); // no February 30
+    /// ~~~~
+    #[inline]
+    fn with_month0(&self, month0: u32) -> Option<NaiveDate> {
+        self.with_mdf(self.mdf().with_month(month0 + 1))
+    }
+
+    /// Makes a new `NaiveDate` with the day of month (starting from 1) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(30),
+    ///            Some(NaiveDate::from_ymd(2015, 9, 30)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day(31),
+    ///            None); // no September 31
+    /// ~~~~
+    #[inline]
+    fn with_day(&self, day: u32) -> Option<NaiveDate> {
+        self.with_mdf(self.mdf().with_day(day))
+    }
+
+    /// Makes a new `NaiveDate` with the day of month (starting from 0) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(29),
+    ///            Some(NaiveDate::from_ymd(2015, 9, 30)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 9, 8).with_day0(30),
+    ///            None); // no September 31
+    /// ~~~~
+    #[inline]
+    fn with_day0(&self, day0: u32) -> Option<NaiveDate> {
+        self.with_mdf(self.mdf().with_day(day0 + 1))
+    }
+
+    /// Makes a new `NaiveDate` with the day of year (starting from 1) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(60),
+    ///            Some(NaiveDate::from_ymd(2015, 3, 1)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal(366),
+    ///            None); // 2015 had only 365 days
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(60),
+    ///            Some(NaiveDate::from_ymd(2016, 2, 29)));
+    /// assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal(366),
+    ///            Some(NaiveDate::from_ymd(2016, 12, 31)));
+    /// ~~~~
+    #[inline]
+    fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDate> {
+        self.with_of(self.of().with_ordinal(ordinal))
+    }
+
+    /// Makes a new `NaiveDate` with the day of year (starting from 0) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDate` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike};
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(59),
+    ///            Some(NaiveDate::from_ymd(2015, 3, 1)));
+    /// assert_eq!(NaiveDate::from_ymd(2015, 1, 1).with_ordinal0(365),
+    ///            None); // 2015 had only 365 days
+    ///
+    /// assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(59),
+    ///            Some(NaiveDate::from_ymd(2016, 2, 29)));
+    /// assert_eq!(NaiveDate::from_ymd(2016, 1, 1).with_ordinal0(365),
+    ///            Some(NaiveDate::from_ymd(2016, 12, 31)));
+    /// ~~~~
+    #[inline]
+    fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDate> {
+        self.with_of(self.of().with_ordinal(ordinal0 + 1))
+    }
+}
+
+/// An addition of `Duration` to `NaiveDate` discards the fractional days,
+/// rounding to the closest integral number of days towards `Duration::zero()`.
+///
+/// Panics on underflow or overflow.
+/// Use [`NaiveDate::checked_add_signed`](#method.checked_add_signed) to detect that.
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveDate};
+///
+/// let from_ymd = NaiveDate::from_ymd;
+///
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::zero(),             from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(86399),     from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(-86399),    from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::days(1),            from_ymd(2014, 1, 2));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::days(-1),           from_ymd(2013, 12, 31));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::days(364),          from_ymd(2014, 12, 31));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*4 + 1),    from_ymd(2018, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*400 + 97), from_ymd(2414, 1, 1));
+/// # }
+/// ~~~~
+impl Add<OldDuration> for NaiveDate {
+    type Output = NaiveDate;
+
+    #[inline]
+    fn add(self, rhs: OldDuration) -> NaiveDate {
+        self.checked_add_signed(rhs).expect("`NaiveDate + Duration` overflowed")
+    }
+}
+
+impl AddAssign<OldDuration> for NaiveDate {
+    #[inline]
+    fn add_assign(&mut self, rhs: OldDuration) {
+        *self = self.add(rhs);
+    }
+}
+
+/// A subtraction of `Duration` from `NaiveDate` discards the fractional days,
+/// rounding to the closest integral number of days towards `Duration::zero()`.
+/// It is the same as the addition with a negated `Duration`.
+///
+/// Panics on underflow or overflow.
+/// Use [`NaiveDate::checked_sub_signed`](#method.checked_sub_signed) to detect that.
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveDate};
+///
+/// let from_ymd = NaiveDate::from_ymd;
+///
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(),             from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399),     from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399),    from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1),            from_ymd(2013, 12, 31));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1),           from_ymd(2014, 1, 2));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364),          from_ymd(2013, 1, 2));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1),    from_ymd(2010, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));
+/// # }
+/// ~~~~
+impl Sub<OldDuration> for NaiveDate {
+    type Output = NaiveDate;
+
+    #[inline]
+    fn sub(self, rhs: OldDuration) -> NaiveDate {
+        self.checked_sub_signed(rhs).expect("`NaiveDate - Duration` overflowed")
+    }
+}
+
+impl SubAssign<OldDuration> for NaiveDate {
+    #[inline]
+    fn sub_assign(&mut self, rhs: OldDuration) {
+        *self = self.sub(rhs);
+    }
+}
+
+/// Subtracts another `NaiveDate` from the current date.
+/// Returns a `Duration` of integral numbers.
+///
+/// This does not overflow or underflow at all,
+/// as all possible output fits in the range of `Duration`.
+///
+/// The implementation is a wrapper around
+/// [`NaiveDate::signed_duration_since`](#method.signed_duration_since).
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveDate};
+///
+/// let from_ymd = NaiveDate::from_ymd;
+///
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), Duration::zero());
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), Duration::days(1));
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), Duration::days(-1));
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), Duration::days(100));
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), Duration::days(365));
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1), Duration::days(365*4 + 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1), Duration::days(365*400 + 97));
+/// # }
+/// ~~~~
+impl Sub<NaiveDate> for NaiveDate {
+    type Output = OldDuration;
+
+    #[inline]
+    fn sub(self, rhs: NaiveDate) -> OldDuration {
+        self.signed_duration_since(rhs)
+    }
+}
+
+/// Iterator over `NaiveDate` with a step size of one day.
+#[derive(Debug, Copy, Clone, Hash, PartialEq, PartialOrd, Eq, Ord)]
+pub struct NaiveDateDaysIterator {
+    value: NaiveDate,
+}
+
+impl Iterator for NaiveDateDaysIterator {
+    type Item = NaiveDate;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.value == MAX_DATE {
+            return None;
+        }
+        // current < MAX_DATE from here on:
+        let current = self.value;
+        // This can't panic because current is < MAX_DATE:
+        self.value = current.succ();
+        Some(current)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let exact_size = MAX_DATE.signed_duration_since(self.value).num_days();
+        (exact_size as usize, Some(exact_size as usize))
+    }
+}
+
+impl ExactSizeIterator for NaiveDateDaysIterator {}
+
+#[derive(Debug, Copy, Clone, Hash, PartialEq, PartialOrd, Eq, Ord)]
+pub struct NaiveDateWeeksIterator {
+    value: NaiveDate,
+}
+
+impl Iterator for NaiveDateWeeksIterator {
+    type Item = NaiveDate;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if MAX_DATE - self.value < OldDuration::weeks(1) {
+            return None;
+        }
+        let current = self.value;
+        self.value = current + OldDuration::weeks(1);
+        Some(current)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let exact_size = MAX_DATE.signed_duration_since(self.value).num_weeks();
+        (exact_size as usize, Some(exact_size as usize))
+    }
+}
+
+impl ExactSizeIterator for NaiveDateWeeksIterator {}
+
+// TODO: NaiveDateDaysIterator and NaiveDateWeeksIterator should implement FusedIterator,
+// TrustedLen, and Step once they becomes stable.
+// See: https://github.com/chronotope/chrono/issues/208
+
+/// The `Debug` output of the naive date `d` is the same as
+/// [`d.format("%Y-%m-%d")`](../format/strftime/index.html).
+///
+/// The string printed can be readily parsed via the `parse` method on `str`.
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveDate;
+///
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");
+/// ~~~~
+///
+/// ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
+///
+/// ~~~~
+/// # use chrono::NaiveDate;
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");
+/// ~~~~
+impl fmt::Debug for NaiveDate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let year = self.year();
+        let mdf = self.mdf();
+        if 0 <= year && year <= 9999 {
+            write!(f, "{:04}-{:02}-{:02}", year, mdf.month(), mdf.day())
+        } else {
+            // ISO 8601 requires the explicit sign for out-of-range years
+            write!(f, "{:+05}-{:02}-{:02}", year, mdf.month(), mdf.day())
+        }
+    }
+}
+
+/// The `Display` output of the naive date `d` is the same as
+/// [`d.format("%Y-%m-%d")`](../format/strftime/index.html).
+///
+/// The string printed can be readily parsed via the `parse` method on `str`.
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveDate;
+///
+/// assert_eq!(format!("{}", NaiveDate::from_ymd(2015,  9,  5)), "2015-09-05");
+/// assert_eq!(format!("{}", NaiveDate::from_ymd(   0,  1,  1)), "0000-01-01");
+/// assert_eq!(format!("{}", NaiveDate::from_ymd(9999, 12, 31)), "9999-12-31");
+/// ~~~~
+///
+/// ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
+///
+/// ~~~~
+/// # use chrono::NaiveDate;
+/// assert_eq!(format!("{}", NaiveDate::from_ymd(   -1,  1,  1)),  "-0001-01-01");
+/// assert_eq!(format!("{}", NaiveDate::from_ymd(10000, 12, 31)), "+10000-12-31");
+/// ~~~~
+impl fmt::Display for NaiveDate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
+
+/// Parsing a `str` into a `NaiveDate` uses the same format,
+/// [`%Y-%m-%d`](../format/strftime/index.html), as in `Debug` and `Display`.
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveDate;
+///
+/// let d = NaiveDate::from_ymd(2015, 9, 18);
+/// assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));
+///
+/// let d = NaiveDate::from_ymd(12345, 6, 7);
+/// assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));
+///
+/// assert!("foo".parse::<NaiveDate>().is_err());
+/// ~~~~
+impl str::FromStr for NaiveDate {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> ParseResult<NaiveDate> {
+        const ITEMS: &'static [Item<'static>] = &[
+            Item::Numeric(Numeric::Year, Pad::Zero),
+            Item::Space(""),
+            Item::Literal("-"),
+            Item::Numeric(Numeric::Month, Pad::Zero),
+            Item::Space(""),
+            Item::Literal("-"),
+            Item::Numeric(Numeric::Day, Pad::Zero),
+            Item::Space(""),
+        ];
+
+        let mut parsed = Parsed::new();
+        parse(&mut parsed, s, ITEMS.iter())?;
+        parsed.to_naive_date()
+    }
+}
+
+#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))]
+fn test_encodable_json<F, E>(to_string: F)
+where
+    F: Fn(&NaiveDate) -> Result<String, E>,
+    E: ::std::fmt::Debug,
+{
+    assert_eq!(to_string(&NaiveDate::from_ymd(2014, 7, 24)).ok(), Some(r#""2014-07-24""#.into()));
+    assert_eq!(to_string(&NaiveDate::from_ymd(0, 1, 1)).ok(), Some(r#""0000-01-01""#.into()));
+    assert_eq!(to_string(&NaiveDate::from_ymd(-1, 12, 31)).ok(), Some(r#""-0001-12-31""#.into()));
+    assert_eq!(to_string(&MIN_DATE).ok(), Some(r#""-262144-01-01""#.into()));
+    assert_eq!(to_string(&MAX_DATE).ok(), Some(r#""+262143-12-31""#.into()));
+}
+
+#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))]
+fn test_decodable_json<F, E>(from_str: F)
+where
+    F: Fn(&str) -> Result<NaiveDate, E>,
+    E: ::std::fmt::Debug,
+{
+    use std::{i32, i64};
+
+    assert_eq!(from_str(r#""2016-07-08""#).ok(), Some(NaiveDate::from_ymd(2016, 7, 8)));
+    assert_eq!(from_str(r#""2016-7-8""#).ok(), Some(NaiveDate::from_ymd(2016, 7, 8)));
+    assert_eq!(from_str(r#""+002016-07-08""#).ok(), Some(NaiveDate::from_ymd(2016, 7, 8)));
+    assert_eq!(from_str(r#""0000-01-01""#).ok(), Some(NaiveDate::from_ymd(0, 1, 1)));
+    assert_eq!(from_str(r#""0-1-1""#).ok(), Some(NaiveDate::from_ymd(0, 1, 1)));
+    assert_eq!(from_str(r#""-0001-12-31""#).ok(), Some(NaiveDate::from_ymd(-1, 12, 31)));
+    assert_eq!(from_str(r#""-262144-01-01""#).ok(), Some(MIN_DATE));
+    assert_eq!(from_str(r#""+262143-12-31""#).ok(), Some(MAX_DATE));
+
+    // bad formats
+    assert!(from_str(r#""""#).is_err());
+    assert!(from_str(r#""20001231""#).is_err());
+    assert!(from_str(r#""2000-00-00""#).is_err());
+    assert!(from_str(r#""2000-02-30""#).is_err());
+    assert!(from_str(r#""2001-02-29""#).is_err());
+    assert!(from_str(r#""2002-002-28""#).is_err());
+    assert!(from_str(r#""yyyy-mm-dd""#).is_err());
+    assert!(from_str(r#"0"#).is_err());
+    assert!(from_str(r#"20.01"#).is_err());
+    assert!(from_str(&i32::MIN.to_string()).is_err());
+    assert!(from_str(&i32::MAX.to_string()).is_err());
+    assert!(from_str(&i64::MIN.to_string()).is_err());
+    assert!(from_str(&i64::MAX.to_string()).is_err());
+    assert!(from_str(r#"{}"#).is_err());
+    // pre-0.3.0 rustc-serialize format is now invalid
+    assert!(from_str(r#"{"ymdf":20}"#).is_err());
+    assert!(from_str(r#"null"#).is_err());
+}
+
+#[cfg(feature = "rustc-serialize")]
+mod rustc_serialize {
+    use super::NaiveDate;
+    use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+
+    impl Encodable for NaiveDate {
+        fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+            format!("{:?}", self).encode(s)
+        }
+    }
+
+    impl Decodable for NaiveDate {
+        fn decode<D: Decoder>(d: &mut D) -> Result<NaiveDate, D::Error> {
+            d.read_str()?.parse().map_err(|_| d.error("invalid date"))
+        }
+    }
+
+    #[cfg(test)]
+    use rustc_serialize::json;
+
+    #[test]
+    fn test_encodable() {
+        super::test_encodable_json(json::encode);
+    }
+
+    #[test]
+    fn test_decodable() {
+        super::test_decodable_json(json::decode);
+    }
+}
+
+#[cfg(feature = "serde")]
+mod serde {
+    use super::NaiveDate;
+    use core::fmt;
+    use serdelib::{de, ser};
+
+    // TODO not very optimized for space (binary formats would want something better)
+
+    impl ser::Serialize for NaiveDate {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: ser::Serializer,
+        {
+            struct FormatWrapped<'a, D: 'a> {
+                inner: &'a D,
+            }
+
+            impl<'a, D: fmt::Debug> fmt::Display for FormatWrapped<'a, D> {
+                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    self.inner.fmt(f)
+                }
+            }
+
+            serializer.collect_str(&FormatWrapped { inner: &self })
+        }
+    }
+
+    struct NaiveDateVisitor;
+
+    impl<'de> de::Visitor<'de> for NaiveDateVisitor {
+        type Value = NaiveDate;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            write!(formatter, "a formatted date string")
+        }
+
+        #[cfg(any(feature = "std", test))]
+        fn visit_str<E>(self, value: &str) -> Result<NaiveDate, E>
+        where
+            E: de::Error,
+        {
+            value.parse().map_err(E::custom)
+        }
+
+        #[cfg(not(any(feature = "std", test)))]
+        fn visit_str<E>(self, value: &str) -> Result<NaiveDate, E>
+        where
+            E: de::Error,
+        {
+            value.parse().map_err(E::custom)
+        }
+    }
+
+    impl<'de> de::Deserialize<'de> for NaiveDate {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            deserializer.deserialize_str(NaiveDateVisitor)
+        }
+    }
+
+    #[cfg(test)]
+    extern crate bincode;
+    #[cfg(test)]
+    extern crate serde_json;
+
+    #[test]
+    fn test_serde_serialize() {
+        super::test_encodable_json(self::serde_json::to_string);
+    }
+
+    #[test]
+    fn test_serde_deserialize() {
+        super::test_decodable_json(|input| self::serde_json::from_str(&input));
+    }
+
+    #[test]
+    fn test_serde_bincode() {
+        // Bincode is relevant to test separately from JSON because
+        // it is not self-describing.
+        use self::bincode::{deserialize, serialize, Infinite};
+
+        let d = NaiveDate::from_ymd(2014, 7, 24);
+        let encoded = serialize(&d, Infinite).unwrap();
+        let decoded: NaiveDate = deserialize(&encoded).unwrap();
+        assert_eq!(d, decoded);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::NaiveDate;
+    use super::{MAX_DATE, MAX_DAYS_FROM_YEAR_0, MAX_YEAR};
+    use super::{MIN_DATE, MIN_DAYS_FROM_YEAR_0, MIN_YEAR};
+    use oldtime::Duration;
+    use std::{i32, u32};
+    use {Datelike, Weekday};
+
+    #[test]
+    fn test_date_from_ymd() {
+        let ymd_opt = |y, m, d| NaiveDate::from_ymd_opt(y, m, d);
+
+        assert!(ymd_opt(2012, 0, 1).is_none());
+        assert!(ymd_opt(2012, 1, 1).is_some());
+        assert!(ymd_opt(2012, 2, 29).is_some());
+        assert!(ymd_opt(2014, 2, 29).is_none());
+        assert!(ymd_opt(2014, 3, 0).is_none());
+        assert!(ymd_opt(2014, 3, 1).is_some());
+        assert!(ymd_opt(2014, 3, 31).is_some());
+        assert!(ymd_opt(2014, 3, 32).is_none());
+        assert!(ymd_opt(2014, 12, 31).is_some());
+        assert!(ymd_opt(2014, 13, 1).is_none());
+    }
+
+    #[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);
+
+        assert_eq!(yo_opt(2012, 0), None);
+        assert_eq!(yo_opt(2012, 1), Some(ymd(2012, 1, 1)));
+        assert_eq!(yo_opt(2012, 2), Some(ymd(2012, 1, 2)));
+        assert_eq!(yo_opt(2012, 32), Some(ymd(2012, 2, 1)));
+        assert_eq!(yo_opt(2012, 60), Some(ymd(2012, 2, 29)));
+        assert_eq!(yo_opt(2012, 61), Some(ymd(2012, 3, 1)));
+        assert_eq!(yo_opt(2012, 100), Some(ymd(2012, 4, 9)));
+        assert_eq!(yo_opt(2012, 200), Some(ymd(2012, 7, 18)));
+        assert_eq!(yo_opt(2012, 300), Some(ymd(2012, 10, 26)));
+        assert_eq!(yo_opt(2012, 366), Some(ymd(2012, 12, 31)));
+        assert_eq!(yo_opt(2012, 367), None);
+
+        assert_eq!(yo_opt(2014, 0), None);
+        assert_eq!(yo_opt(2014, 1), Some(ymd(2014, 1, 1)));
+        assert_eq!(yo_opt(2014, 2), Some(ymd(2014, 1, 2)));
+        assert_eq!(yo_opt(2014, 32), Some(ymd(2014, 2, 1)));
+        assert_eq!(yo_opt(2014, 59), Some(ymd(2014, 2, 28)));
+        assert_eq!(yo_opt(2014, 60), Some(ymd(2014, 3, 1)));
+        assert_eq!(yo_opt(2014, 100), Some(ymd(2014, 4, 10)));
+        assert_eq!(yo_opt(2014, 200), Some(ymd(2014, 7, 19)));
+        assert_eq!(yo_opt(2014, 300), Some(ymd(2014, 10, 27)));
+        assert_eq!(yo_opt(2014, 365), Some(ymd(2014, 12, 31)));
+        assert_eq!(yo_opt(2014, 366), None);
+    }
+
+    #[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);
+
+        assert_eq!(isoywd_opt(2004, 0, Weekday::Sun), None);
+        assert_eq!(isoywd_opt(2004, 1, Weekday::Mon), Some(ymd(2003, 12, 29)));
+        assert_eq!(isoywd_opt(2004, 1, Weekday::Sun), Some(ymd(2004, 1, 4)));
+        assert_eq!(isoywd_opt(2004, 2, Weekday::Mon), Some(ymd(2004, 1, 5)));
+        assert_eq!(isoywd_opt(2004, 2, Weekday::Sun), Some(ymd(2004, 1, 11)));
+        assert_eq!(isoywd_opt(2004, 52, Weekday::Mon), Some(ymd(2004, 12, 20)));
+        assert_eq!(isoywd_opt(2004, 52, Weekday::Sun), Some(ymd(2004, 12, 26)));
+        assert_eq!(isoywd_opt(2004, 53, Weekday::Mon), Some(ymd(2004, 12, 27)));
+        assert_eq!(isoywd_opt(2004, 53, Weekday::Sun), Some(ymd(2005, 1, 2)));
+        assert_eq!(isoywd_opt(2004, 54, Weekday::Mon), None);
+
+        assert_eq!(isoywd_opt(2011, 0, Weekday::Sun), None);
+        assert_eq!(isoywd_opt(2011, 1, Weekday::Mon), Some(ymd(2011, 1, 3)));
+        assert_eq!(isoywd_opt(2011, 1, Weekday::Sun), Some(ymd(2011, 1, 9)));
+        assert_eq!(isoywd_opt(2011, 2, Weekday::Mon), Some(ymd(2011, 1, 10)));
+        assert_eq!(isoywd_opt(2011, 2, Weekday::Sun), Some(ymd(2011, 1, 16)));
+
+        assert_eq!(isoywd_opt(2018, 51, Weekday::Mon), Some(ymd(2018, 12, 17)));
+        assert_eq!(isoywd_opt(2018, 51, Weekday::Sun), Some(ymd(2018, 12, 23)));
+        assert_eq!(isoywd_opt(2018, 52, Weekday::Mon), Some(ymd(2018, 12, 24)));
+        assert_eq!(isoywd_opt(2018, 52, Weekday::Sun), Some(ymd(2018, 12, 30)));
+        assert_eq!(isoywd_opt(2018, 53, Weekday::Mon), None);
+    }
+
+    #[test]
+    fn test_date_from_isoywd_and_iso_week() {
+        for year in 2000..2401 {
+            for week in 1..54 {
+                for &weekday in [
+                    Weekday::Mon,
+                    Weekday::Tue,
+                    Weekday::Wed,
+                    Weekday::Thu,
+                    Weekday::Fri,
+                    Weekday::Sat,
+                    Weekday::Sun,
+                ]
+                .iter()
+                {
+                    let d = NaiveDate::from_isoywd_opt(year, week, weekday);
+                    if d.is_some() {
+                        let d = d.unwrap();
+                        assert_eq!(d.weekday(), weekday);
+                        let w = d.iso_week();
+                        assert_eq!(w.year(), year);
+                        assert_eq!(w.week(), week);
+                    }
+                }
+            }
+        }
+
+        for year in 2000..2401 {
+            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();
+                        let w = d.iso_week();
+                        let d_ = NaiveDate::from_isoywd(w.year(), w.week(), d.weekday());
+                        assert_eq!(d, d_);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_date_from_num_days_from_ce() {
+        let from_ndays_from_ce = |days| NaiveDate::from_num_days_from_ce_opt(days);
+        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)));
+        assert_eq!(from_ndays_from_ce(32), Some(NaiveDate::from_ymd(1, 2, 1)));
+        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 * 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)));
+        assert_eq!(from_ndays_from_ce(146097 + 1), Some(NaiveDate::from_ymd(401, 1, 1)));
+        assert_eq!(from_ndays_from_ce(146097 * 5 + 1), Some(NaiveDate::from_ymd(2001, 1, 1)));
+        assert_eq!(from_ndays_from_ce(719163), Some(NaiveDate::from_ymd(1970, 1, 1)));
+        assert_eq!(from_ndays_from_ce(0), Some(NaiveDate::from_ymd(0, 12, 31))); // 1 BCE
+        assert_eq!(from_ndays_from_ce(-365), Some(NaiveDate::from_ymd(0, 1, 1)));
+        assert_eq!(from_ndays_from_ce(-366), Some(NaiveDate::from_ymd(-1, 12, 31))); // 2 BCE
+
+        for days in (-9999..10001).map(|x| x * 100) {
+            assert_eq!(from_ndays_from_ce(days).map(|d| d.num_days_from_ce()), Some(days));
+        }
+
+        assert_eq!(from_ndays_from_ce(MIN_DATE.num_days_from_ce()), Some(MIN_DATE));
+        assert_eq!(from_ndays_from_ce(MIN_DATE.num_days_from_ce() - 1), None);
+        assert_eq!(from_ndays_from_ce(MAX_DATE.num_days_from_ce()), Some(MAX_DATE));
+        assert_eq!(from_ndays_from_ce(MAX_DATE.num_days_from_ce() + 1), None);
+    }
+
+    #[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);
+        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)));
+        assert_eq!(ymwd(2018, 8, Weekday::Sun, 1), Some(NaiveDate::from_ymd(2018, 8, 5)));
+        assert_eq!(ymwd(2018, 8, Weekday::Mon, 1), Some(NaiveDate::from_ymd(2018, 8, 6)));
+        assert_eq!(ymwd(2018, 8, Weekday::Tue, 1), Some(NaiveDate::from_ymd(2018, 8, 7)));
+        assert_eq!(ymwd(2018, 8, Weekday::Wed, 2), Some(NaiveDate::from_ymd(2018, 8, 8)));
+        assert_eq!(ymwd(2018, 8, Weekday::Sun, 2), Some(NaiveDate::from_ymd(2018, 8, 12)));
+        assert_eq!(ymwd(2018, 8, Weekday::Thu, 3), Some(NaiveDate::from_ymd(2018, 8, 16)));
+        assert_eq!(ymwd(2018, 8, Weekday::Thu, 4), Some(NaiveDate::from_ymd(2018, 8, 23)));
+        assert_eq!(ymwd(2018, 8, Weekday::Thu, 5), Some(NaiveDate::from_ymd(2018, 8, 30)));
+        assert_eq!(ymwd(2018, 8, Weekday::Fri, 5), Some(NaiveDate::from_ymd(2018, 8, 31)));
+        assert_eq!(ymwd(2018, 8, Weekday::Sat, 5), None);
+    }
+
+    #[test]
+    fn test_date_fields() {
+        fn check(year: i32, month: u32, day: u32, ordinal: u32) {
+            let d1 = NaiveDate::from_ymd(year, month, day);
+            assert_eq!(d1.year(), year);
+            assert_eq!(d1.month(), month);
+            assert_eq!(d1.day(), day);
+            assert_eq!(d1.ordinal(), ordinal);
+
+            let d2 = NaiveDate::from_yo(year, ordinal);
+            assert_eq!(d2.year(), year);
+            assert_eq!(d2.month(), month);
+            assert_eq!(d2.day(), day);
+            assert_eq!(d2.ordinal(), ordinal);
+
+            assert_eq!(d1, d2);
+        }
+
+        check(2012, 1, 1, 1);
+        check(2012, 1, 2, 2);
+        check(2012, 2, 1, 32);
+        check(2012, 2, 29, 60);
+        check(2012, 3, 1, 61);
+        check(2012, 4, 9, 100);
+        check(2012, 7, 18, 200);
+        check(2012, 10, 26, 300);
+        check(2012, 12, 31, 366);
+
+        check(2014, 1, 1, 1);
+        check(2014, 1, 2, 2);
+        check(2014, 2, 1, 32);
+        check(2014, 2, 28, 59);
+        check(2014, 3, 1, 60);
+        check(2014, 4, 10, 100);
+        check(2014, 7, 19, 200);
+        check(2014, 10, 27, 300);
+        check(2014, 12, 31, 365);
+    }
+
+    #[test]
+    fn test_date_weekday() {
+        assert_eq!(NaiveDate::from_ymd(1582, 10, 15).weekday(), Weekday::Fri);
+        // May 20, 1875 = ISO 8601 reference date
+        assert_eq!(NaiveDate::from_ymd(1875, 5, 20).weekday(), Weekday::Thu);
+        assert_eq!(NaiveDate::from_ymd(2000, 1, 1).weekday(), Weekday::Sat);
+    }
+
+    #[test]
+    fn test_date_with_fields() {
+        let d = NaiveDate::from_ymd(2000, 2, 29);
+        assert_eq!(d.with_year(-400), Some(NaiveDate::from_ymd(-400, 2, 29)));
+        assert_eq!(d.with_year(-100), None);
+        assert_eq!(d.with_year(1600), Some(NaiveDate::from_ymd(1600, 2, 29)));
+        assert_eq!(d.with_year(1900), None);
+        assert_eq!(d.with_year(2000), Some(NaiveDate::from_ymd(2000, 2, 29)));
+        assert_eq!(d.with_year(2001), None);
+        assert_eq!(d.with_year(2004), Some(NaiveDate::from_ymd(2004, 2, 29)));
+        assert_eq!(d.with_year(i32::MAX), None);
+
+        let d = NaiveDate::from_ymd(2000, 4, 30);
+        assert_eq!(d.with_month(0), None);
+        assert_eq!(d.with_month(1), Some(NaiveDate::from_ymd(2000, 1, 30)));
+        assert_eq!(d.with_month(2), None);
+        assert_eq!(d.with_month(3), Some(NaiveDate::from_ymd(2000, 3, 30)));
+        assert_eq!(d.with_month(4), Some(NaiveDate::from_ymd(2000, 4, 30)));
+        assert_eq!(d.with_month(12), Some(NaiveDate::from_ymd(2000, 12, 30)));
+        assert_eq!(d.with_month(13), None);
+        assert_eq!(d.with_month(u32::MAX), None);
+
+        let d = NaiveDate::from_ymd(2000, 2, 8);
+        assert_eq!(d.with_day(0), None);
+        assert_eq!(d.with_day(1), Some(NaiveDate::from_ymd(2000, 2, 1)));
+        assert_eq!(d.with_day(29), Some(NaiveDate::from_ymd(2000, 2, 29)));
+        assert_eq!(d.with_day(30), None);
+        assert_eq!(d.with_day(u32::MAX), None);
+
+        let d = NaiveDate::from_ymd(2000, 5, 5);
+        assert_eq!(d.with_ordinal(0), None);
+        assert_eq!(d.with_ordinal(1), Some(NaiveDate::from_ymd(2000, 1, 1)));
+        assert_eq!(d.with_ordinal(60), Some(NaiveDate::from_ymd(2000, 2, 29)));
+        assert_eq!(d.with_ordinal(61), Some(NaiveDate::from_ymd(2000, 3, 1)));
+        assert_eq!(d.with_ordinal(366), Some(NaiveDate::from_ymd(2000, 12, 31)));
+        assert_eq!(d.with_ordinal(367), None);
+        assert_eq!(d.with_ordinal(u32::MAX), None);
+    }
+
+    #[test]
+    fn test_date_num_days_from_ce() {
+        assert_eq!(NaiveDate::from_ymd(1, 1, 1).num_days_from_ce(), 1);
+
+        for year in -9999..10001 {
+            assert_eq!(
+                NaiveDate::from_ymd(year, 1, 1).num_days_from_ce(),
+                NaiveDate::from_ymd(year - 1, 12, 31).num_days_from_ce() + 1
+            );
+        }
+    }
+
+    #[test]
+    fn test_date_succ() {
+        let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d);
+        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)));
+        assert_eq!(ymd(2016, 2, 28).succ_opt(), Some(ymd(2016, 2, 29)));
+        assert_eq!(ymd(MAX_DATE.year(), 12, 31).succ_opt(), None);
+    }
+
+    #[test]
+    fn test_date_pred() {
+        let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d);
+        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)));
+        assert_eq!(ymd(2014, 5, 7).pred_opt(), Some(ymd(2014, 5, 6)));
+        assert_eq!(ymd(MIN_DATE.year(), 1, 1).pred_opt(), None);
+    }
+
+    #[test]
+    fn test_date_add() {
+        fn check((y1, m1, d1): (i32, u32, u32), rhs: Duration, ymd: Option<(i32, u32, u32)>) {
+            let lhs = NaiveDate::from_ymd(y1, m1, d1);
+            let sum = ymd.map(|(y, m, d)| NaiveDate::from_ymd(y, m, d));
+            assert_eq!(lhs.checked_add_signed(rhs), sum);
+            assert_eq!(lhs.checked_sub_signed(-rhs), sum);
+        }
+
+        check((2014, 1, 1), Duration::zero(), Some((2014, 1, 1)));
+        check((2014, 1, 1), Duration::seconds(86399), Some((2014, 1, 1)));
+        // always round towards zero
+        check((2014, 1, 1), Duration::seconds(-86399), Some((2014, 1, 1)));
+        check((2014, 1, 1), Duration::days(1), Some((2014, 1, 2)));
+        check((2014, 1, 1), Duration::days(-1), Some((2013, 12, 31)));
+        check((2014, 1, 1), Duration::days(364), Some((2014, 12, 31)));
+        check((2014, 1, 1), Duration::days(365 * 4 + 1), Some((2018, 1, 1)));
+        check((2014, 1, 1), Duration::days(365 * 400 + 97), Some((2414, 1, 1)));
+
+        check((-7, 1, 1), Duration::days(365 * 12 + 3), Some((5, 1, 1)));
+
+        // overflow check
+        check((0, 1, 1), Duration::days(MAX_DAYS_FROM_YEAR_0 as i64), Some((MAX_YEAR, 12, 31)));
+        check((0, 1, 1), Duration::days(MAX_DAYS_FROM_YEAR_0 as i64 + 1), None);
+        check((0, 1, 1), Duration::max_value(), None);
+        check((0, 1, 1), Duration::days(MIN_DAYS_FROM_YEAR_0 as i64), Some((MIN_YEAR, 1, 1)));
+        check((0, 1, 1), Duration::days(MIN_DAYS_FROM_YEAR_0 as i64 - 1), None);
+        check((0, 1, 1), Duration::min_value(), None);
+    }
+
+    #[test]
+    fn test_date_sub() {
+        fn check((y1, m1, d1): (i32, u32, u32), (y2, m2, d2): (i32, u32, u32), diff: Duration) {
+            let lhs = NaiveDate::from_ymd(y1, m1, d1);
+            let rhs = NaiveDate::from_ymd(y2, m2, d2);
+            assert_eq!(lhs.signed_duration_since(rhs), diff);
+            assert_eq!(rhs.signed_duration_since(lhs), -diff);
+        }
+
+        check((2014, 1, 1), (2014, 1, 1), Duration::zero());
+        check((2014, 1, 2), (2014, 1, 1), Duration::days(1));
+        check((2014, 12, 31), (2014, 1, 1), Duration::days(364));
+        check((2015, 1, 3), (2014, 1, 1), Duration::days(365 + 2));
+        check((2018, 1, 1), (2014, 1, 1), Duration::days(365 * 4 + 1));
+        check((2414, 1, 1), (2014, 1, 1), Duration::days(365 * 400 + 97));
+
+        check((MAX_YEAR, 12, 31), (0, 1, 1), Duration::days(MAX_DAYS_FROM_YEAR_0 as i64));
+        check((MIN_YEAR, 1, 1), (0, 1, 1), Duration::days(MIN_DAYS_FROM_YEAR_0 as i64));
+    }
+
+    #[test]
+    fn test_date_addassignment() {
+        let ymd = NaiveDate::from_ymd;
+        let mut date = ymd(2016, 10, 1);
+        date += Duration::days(10);
+        assert_eq!(date, ymd(2016, 10, 11));
+        date += Duration::days(30);
+        assert_eq!(date, ymd(2016, 11, 10));
+    }
+
+    #[test]
+    fn test_date_subassignment() {
+        let ymd = NaiveDate::from_ymd;
+        let mut date = ymd(2016, 10, 11);
+        date -= Duration::days(10);
+        assert_eq!(date, ymd(2016, 10, 1));
+        date -= Duration::days(2);
+        assert_eq!(date, ymd(2016, 9, 29));
+    }
+
+    #[test]
+    fn test_date_fmt() {
+        assert_eq!(format!("{:?}", NaiveDate::from_ymd(2012, 3, 4)), "2012-03-04");
+        assert_eq!(format!("{:?}", NaiveDate::from_ymd(0, 3, 4)), "0000-03-04");
+        assert_eq!(format!("{:?}", NaiveDate::from_ymd(-307, 3, 4)), "-0307-03-04");
+        assert_eq!(format!("{:?}", NaiveDate::from_ymd(12345, 3, 4)), "+12345-03-04");
+
+        assert_eq!(NaiveDate::from_ymd(2012, 3, 4).to_string(), "2012-03-04");
+        assert_eq!(NaiveDate::from_ymd(0, 3, 4).to_string(), "0000-03-04");
+        assert_eq!(NaiveDate::from_ymd(-307, 3, 4).to_string(), "-0307-03-04");
+        assert_eq!(NaiveDate::from_ymd(12345, 3, 4).to_string(), "+12345-03-04");
+
+        // the format specifier should have no effect on `NaiveTime`
+        assert_eq!(format!("{:+30?}", NaiveDate::from_ymd(1234, 5, 6)), "1234-05-06");
+        assert_eq!(format!("{:30?}", NaiveDate::from_ymd(12345, 6, 7)), "+12345-06-07");
+    }
+
+    #[test]
+    fn test_date_from_str() {
+        // valid cases
+        let valid = [
+            "-0000000123456-1-2",
+            "    -123456 - 1 - 2    ",
+            "-12345-1-2",
+            "-1234-12-31",
+            "-7-6-5",
+            "350-2-28",
+            "360-02-29",
+            "0360-02-29",
+            "2015-2 -18",
+            "+70-2-18",
+            "+70000-2-18",
+            "+00007-2-18",
+        ];
+        for &s in &valid {
+            let d = match s.parse::<NaiveDate>() {
+                Ok(d) => d,
+                Err(e) => panic!("parsing `{}` has failed: {}", s, e),
+            };
+            let s_ = format!("{:?}", d);
+            // `s` and `s_` may differ, but `s.parse()` and `s_.parse()` must be same
+            let d_ = match s_.parse::<NaiveDate>() {
+                Ok(d) => d,
+                Err(e) => {
+                    panic!("`{}` is parsed into `{:?}`, but reparsing that has failed: {}", s, d, e)
+                }
+            };
+            assert!(
+                d == d_,
+                "`{}` is parsed into `{:?}`, but reparsed result \
+                              `{:?}` does not match",
+                s,
+                d,
+                d_
+            );
+        }
+
+        // some invalid cases
+        // since `ParseErrorKind` is private, all we can do is to check if there was an error
+        assert!("".parse::<NaiveDate>().is_err());
+        assert!("x".parse::<NaiveDate>().is_err());
+        assert!("2014".parse::<NaiveDate>().is_err());
+        assert!("2014-01".parse::<NaiveDate>().is_err());
+        assert!("2014-01-00".parse::<NaiveDate>().is_err());
+        assert!("2014-13-57".parse::<NaiveDate>().is_err());
+        assert!("9999999-9-9".parse::<NaiveDate>().is_err()); // out-of-bounds
+    }
+
+    #[test]
+    fn test_date_parse_from_str() {
+        let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d);
+        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))
+        ); // ignore time and offset
+        assert_eq!(
+            NaiveDate::parse_from_str("2015-W06-1=2015-033", "%G-W%V-%u = %Y-%j"),
+            Ok(ymd(2015, 2, 2))
+        );
+        assert_eq!(
+            NaiveDate::parse_from_str("Fri, 09 Aug 13", "%a, %d %b %y"),
+            Ok(ymd(2013, 8, 9))
+        );
+        assert!(NaiveDate::parse_from_str("Sat, 09 Aug 2013", "%a, %d %b %Y").is_err());
+        assert!(NaiveDate::parse_from_str("2014-57", "%Y-%m-%d").is_err());
+        assert!(NaiveDate::parse_from_str("2014", "%Y").is_err()); // insufficient
+    }
+
+    #[test]
+    fn test_date_format() {
+        let d = NaiveDate::from_ymd(2012, 3, 4);
+        assert_eq!(d.format("%Y,%C,%y,%G,%g").to_string(), "2012,20,12,2012,12");
+        assert_eq!(d.format("%m,%b,%h,%B").to_string(), "03,Mar,Mar,March");
+        assert_eq!(d.format("%d,%e").to_string(), "04, 4");
+        assert_eq!(d.format("%U,%W,%V").to_string(), "10,09,09");
+        assert_eq!(d.format("%a,%A,%w,%u").to_string(), "Sun,Sunday,0,7");
+        assert_eq!(d.format("%j").to_string(), "064"); // since 2012 is a leap year
+        assert_eq!(d.format("%D,%x").to_string(), "03/04/12,03/04/12");
+        assert_eq!(d.format("%F").to_string(), "2012-03-04");
+        assert_eq!(d.format("%v").to_string(), " 4-Mar-2012");
+        assert_eq!(d.format("%t%n%%%n%t").to_string(), "\t\n%\n\t");
+
+        // non-four-digit years
+        assert_eq!(NaiveDate::from_ymd(12345, 1, 1).format("%Y").to_string(), "+12345");
+        assert_eq!(NaiveDate::from_ymd(1234, 1, 1).format("%Y").to_string(), "1234");
+        assert_eq!(NaiveDate::from_ymd(123, 1, 1).format("%Y").to_string(), "0123");
+        assert_eq!(NaiveDate::from_ymd(12, 1, 1).format("%Y").to_string(), "0012");
+        assert_eq!(NaiveDate::from_ymd(1, 1, 1).format("%Y").to_string(), "0001");
+        assert_eq!(NaiveDate::from_ymd(0, 1, 1).format("%Y").to_string(), "0000");
+        assert_eq!(NaiveDate::from_ymd(-1, 1, 1).format("%Y").to_string(), "-0001");
+        assert_eq!(NaiveDate::from_ymd(-12, 1, 1).format("%Y").to_string(), "-0012");
+        assert_eq!(NaiveDate::from_ymd(-123, 1, 1).format("%Y").to_string(), "-0123");
+        assert_eq!(NaiveDate::from_ymd(-1234, 1, 1).format("%Y").to_string(), "-1234");
+        assert_eq!(NaiveDate::from_ymd(-12345, 1, 1).format("%Y").to_string(), "-12345");
+
+        // corner cases
+        assert_eq!(
+            NaiveDate::from_ymd(2007, 12, 31).format("%G,%g,%U,%W,%V").to_string(),
+            "2008,08,53,53,01"
+        );
+        assert_eq!(
+            NaiveDate::from_ymd(2010, 1, 3).format("%G,%g,%U,%W,%V").to_string(),
+            "2009,09,01,00,53"
+        );
+    }
+
+    #[test]
+    fn test_day_iterator_limit() {
+        assert_eq!(
+            NaiveDate::from_ymd(262143, 12, 29).iter_days().take(4).collect::<Vec<_>>().len(),
+            2
+        );
+    }
+
+    #[test]
+    fn test_week_iterator_limit() {
+        assert_eq!(
+            NaiveDate::from_ymd(262143, 12, 12).iter_weeks().take(4).collect::<Vec<_>>().len(),
+            2
+        );
+    }
+}
diff --git a/third_party/rust/chrono/src/naive/datetime.rs b/third_party/rust/chrono/src/naive/datetime.rs
new file mode 100644
index 0000000000..92d6c28554
--- /dev/null
+++ b/third_party/rust/chrono/src/naive/datetime.rs
@@ -0,0 +1,2507 @@
+// This is a part of Chrono.
+// See README.md and LICENSE.txt for details.
+
+//! ISO 8601 date and time without timezone.
+
+#[cfg(any(feature = "alloc", feature = "std", test))]
+use core::borrow::Borrow;
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+use core::{fmt, hash, str};
+use num_traits::ToPrimitive;
+use oldtime::Duration as OldDuration;
+
+use div::div_mod_floor;
+#[cfg(any(feature = "alloc", feature = "std", test))]
+use format::DelayedFormat;
+use format::{parse, ParseError, ParseResult, Parsed, StrftimeItems};
+use format::{Fixed, Item, Numeric, Pad};
+use naive::date::{MAX_DATE, MIN_DATE};
+use naive::time::{MAX_TIME, MIN_TIME};
+use naive::{IsoWeek, NaiveDate, NaiveTime};
+use {Datelike, Timelike, Weekday};
+
+/// The tight upper bound guarantees that a duration with `|Duration| >= 2^MAX_SECS_BITS`
+/// will always overflow the addition with any date and time type.
+///
+/// So why is this needed? `Duration::seconds(rhs)` may overflow, and we don't have
+/// an alternative returning `Option` or `Result`. Thus we need some early bound to avoid
+/// touching that call when we are already sure that it WILL overflow...
+const MAX_SECS_BITS: usize = 44;
+
+/// The minimum possible `NaiveDateTime`.
+pub const MIN_DATETIME: NaiveDateTime = NaiveDateTime { date: MIN_DATE, time: MIN_TIME };
+/// The maximum possible `NaiveDateTime`.
+pub const MAX_DATETIME: NaiveDateTime = NaiveDateTime { date: MAX_DATE, time: MAX_TIME };
+
+/// ISO 8601 combined date and time without timezone.
+///
+/// # Example
+///
+/// `NaiveDateTime` is commonly created from [`NaiveDate`](./struct.NaiveDate.html).
+///
+/// ~~~~
+/// use chrono::{NaiveDate, NaiveDateTime};
+///
+/// let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
+/// # let _ = dt;
+/// ~~~~
+///
+/// You can use typical [date-like](../trait.Datelike.html) and
+/// [time-like](../trait.Timelike.html) methods,
+/// provided that relevant traits are in the scope.
+///
+/// ~~~~
+/// # use chrono::{NaiveDate, NaiveDateTime};
+/// # let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
+/// use chrono::{Datelike, Timelike, Weekday};
+///
+/// assert_eq!(dt.weekday(), Weekday::Fri);
+/// assert_eq!(dt.num_seconds_from_midnight(), 33011);
+/// ~~~~
+#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
+pub struct NaiveDateTime {
+    date: NaiveDate,
+    time: NaiveTime,
+}
+
+impl NaiveDateTime {
+    /// Makes a new `NaiveDateTime` from date and time components.
+    /// Equivalent to [`date.and_time(time)`](./struct.NaiveDate.html#method.and_time)
+    /// and many other helper constructors on `NaiveDate`.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveTime, NaiveDateTime};
+    ///
+    /// let d = NaiveDate::from_ymd(2015, 6, 3);
+    /// let t = NaiveTime::from_hms_milli(12, 34, 56, 789);
+    ///
+    /// let dt = NaiveDateTime::new(d, t);
+    /// assert_eq!(dt.date(), d);
+    /// assert_eq!(dt.time(), t);
+    /// ~~~~
+    #[inline]
+    pub fn new(date: NaiveDate, time: NaiveTime) -> NaiveDateTime {
+        NaiveDateTime { date: date, time: time }
+    }
+
+    /// Makes a new `NaiveDateTime` corresponding to a UTC date and time,
+    /// from the number of non-leap seconds
+    /// since the midnight UTC on January 1, 1970 (aka "UNIX timestamp")
+    /// and the number of nanoseconds since the last whole non-leap second.
+    ///
+    /// For a non-naive version of this function see
+    /// [`TimeZone::timestamp`](../offset/trait.TimeZone.html#method.timestamp).
+    ///
+    /// The nanosecond part can exceed 1,000,000,000 in order to represent the
+    /// [leap second](./struct.NaiveTime.html#leap-second-handling). (The true "UNIX
+    /// timestamp" cannot represent a leap second unambiguously.)
+    ///
+    /// Panics on the out-of-range number of seconds and/or invalid nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDateTime, NaiveDate};
+    ///
+    /// let dt = NaiveDateTime::from_timestamp(0, 42_000_000);
+    /// assert_eq!(dt, NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 0, 42));
+    ///
+    /// let dt = NaiveDateTime::from_timestamp(1_000_000_000, 0);
+    /// assert_eq!(dt, NaiveDate::from_ymd(2001, 9, 9).and_hms(1, 46, 40));
+    /// ~~~~
+    #[inline]
+    pub fn from_timestamp(secs: i64, nsecs: u32) -> NaiveDateTime {
+        let datetime = NaiveDateTime::from_timestamp_opt(secs, nsecs);
+        datetime.expect("invalid or out-of-range datetime")
+    }
+
+    /// Makes a new `NaiveDateTime` corresponding to a UTC date and time,
+    /// from the number of non-leap seconds
+    /// since the midnight UTC on January 1, 1970 (aka "UNIX timestamp")
+    /// and the number of nanoseconds since the last whole non-leap second.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    /// (The true "UNIX timestamp" cannot represent a leap second unambiguously.)
+    ///
+    /// Returns `None` on the out-of-range number of seconds and/or invalid nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDateTime, NaiveDate};
+    /// use std::i64;
+    ///
+    /// let from_timestamp_opt = NaiveDateTime::from_timestamp_opt;
+    ///
+    /// assert!(from_timestamp_opt(0, 0).is_some());
+    /// assert!(from_timestamp_opt(0, 999_999_999).is_some());
+    /// assert!(from_timestamp_opt(0, 1_500_000_000).is_some()); // leap second
+    /// assert!(from_timestamp_opt(0, 2_000_000_000).is_none());
+    /// assert!(from_timestamp_opt(i64::MAX, 0).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn from_timestamp_opt(secs: i64, nsecs: u32) -> Option<NaiveDateTime> {
+        let (days, secs) = div_mod_floor(secs, 86_400);
+        let date = days
+            .to_i32()
+            .and_then(|days| days.checked_add(719_163))
+            .and_then(NaiveDate::from_num_days_from_ce_opt);
+        let time = NaiveTime::from_num_seconds_from_midnight_opt(secs as u32, nsecs);
+        match (date, time) {
+            (Some(date), Some(time)) => Some(NaiveDateTime { date: date, time: time }),
+            (_, _) => None,
+        }
+    }
+
+    /// Parses a string with the specified format string and returns a new `NaiveDateTime`.
+    /// See the [`format::strftime` module](../format/strftime/index.html)
+    /// on the supported escape sequences.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDateTime, NaiveDate};
+    ///
+    /// let parse_from_str = NaiveDateTime::parse_from_str;
+    ///
+    /// assert_eq!(parse_from_str("2015-09-05 23:56:04", "%Y-%m-%d %H:%M:%S"),
+    ///            Ok(NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4)));
+    /// assert_eq!(parse_from_str("5sep2015pm012345.6789", "%d%b%Y%p%I%M%S%.f"),
+    ///            Ok(NaiveDate::from_ymd(2015, 9, 5).and_hms_micro(13, 23, 45, 678_900)));
+    /// ~~~~
+    ///
+    /// Offset is ignored for the purpose of parsing.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveDateTime, NaiveDate};
+    /// # let parse_from_str = NaiveDateTime::parse_from_str;
+    /// assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
+    ///            Ok(NaiveDate::from_ymd(2014, 5, 17).and_hms(12, 34, 56)));
+    /// ~~~~
+    ///
+    /// [Leap seconds](./struct.NaiveTime.html#leap-second-handling) are correctly handled by
+    /// treating any time of the form `hh:mm:60` as a leap second.
+    /// (This equally applies to the formatting, so the round trip is possible.)
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveDateTime, NaiveDate};
+    /// # let parse_from_str = NaiveDateTime::parse_from_str;
+    /// assert_eq!(parse_from_str("2015-07-01 08:59:60.123", "%Y-%m-%d %H:%M:%S%.f"),
+    ///            Ok(NaiveDate::from_ymd(2015, 7, 1).and_hms_milli(8, 59, 59, 1_123)));
+    /// ~~~~
+    ///
+    /// Missing seconds are assumed to be zero,
+    /// but out-of-bound times or insufficient fields are errors otherwise.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveDateTime, NaiveDate};
+    /// # let parse_from_str = NaiveDateTime::parse_from_str;
+    /// assert_eq!(parse_from_str("94/9/4 7:15", "%y/%m/%d %H:%M"),
+    ///            Ok(NaiveDate::from_ymd(1994, 9, 4).and_hms(7, 15, 0)));
+    ///
+    /// assert!(parse_from_str("04m33s", "%Mm%Ss").is_err());
+    /// assert!(parse_from_str("94/9/4 12", "%y/%m/%d %H").is_err());
+    /// assert!(parse_from_str("94/9/4 17:60", "%y/%m/%d %H:%M").is_err());
+    /// assert!(parse_from_str("94/9/4 24:00:00", "%y/%m/%d %H:%M:%S").is_err());
+    /// ~~~~
+    ///
+    /// All parsed fields should be consistent to each other, otherwise it's an error.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDateTime;
+    /// # let parse_from_str = NaiveDateTime::parse_from_str;
+    /// let fmt = "%Y-%m-%d %H:%M:%S = UNIX timestamp %s";
+    /// assert!(parse_from_str("2001-09-09 01:46:39 = UNIX timestamp 999999999", fmt).is_ok());
+    /// assert!(parse_from_str("1970-01-01 00:00:00 = UNIX timestamp 1", fmt).is_err());
+    /// ~~~~
+    pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDateTime> {
+        let mut parsed = Parsed::new();
+        parse(&mut parsed, s, StrftimeItems::new(fmt))?;
+        parsed.to_naive_datetime_with_offset(0) // no offset adjustment
+    }
+
+    /// Retrieves a date component.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
+    /// assert_eq!(dt.date(), NaiveDate::from_ymd(2016, 7, 8));
+    /// ~~~~
+    #[inline]
+    pub fn date(&self) -> NaiveDate {
+        self.date
+    }
+
+    /// Retrieves a time component.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveTime};
+    ///
+    /// let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms(9, 10, 11);
+    /// assert_eq!(dt.time(), NaiveTime::from_hms(9, 10, 11));
+    /// ~~~~
+    #[inline]
+    pub fn time(&self) -> NaiveTime {
+        self.time
+    }
+
+    /// Returns the number of non-leap seconds since the midnight on January 1, 1970.
+    ///
+    /// Note that this does *not* account for the timezone!
+    /// The true "UNIX timestamp" would count seconds since the midnight *UTC* on the epoch.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 980);
+    /// assert_eq!(dt.timestamp(), 1);
+    ///
+    /// let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms(1, 46, 40);
+    /// assert_eq!(dt.timestamp(), 1_000_000_000);
+    ///
+    /// let dt = NaiveDate::from_ymd(1969, 12, 31).and_hms(23, 59, 59);
+    /// assert_eq!(dt.timestamp(), -1);
+    ///
+    /// let dt = NaiveDate::from_ymd(-1, 1, 1).and_hms(0, 0, 0);
+    /// assert_eq!(dt.timestamp(), -62198755200);
+    /// ~~~~
+    #[inline]
+    pub fn timestamp(&self) -> i64 {
+        const UNIX_EPOCH_DAY: i64 = 719_163;
+        let gregorian_day = i64::from(self.date.num_days_from_ce());
+        let seconds_from_midnight = i64::from(self.time.num_seconds_from_midnight());
+        (gregorian_day - UNIX_EPOCH_DAY) * 86_400 + seconds_from_midnight
+    }
+
+    /// Returns the number of non-leap *milliseconds* since midnight on January 1, 1970.
+    ///
+    /// Note that this does *not* account for the timezone!
+    /// The true "UNIX timestamp" would count seconds since the midnight *UTC* on the epoch.
+    ///
+    /// Note also that this does reduce the number of years that can be
+    /// represented from ~584 Billion to ~584 Million. (If this is a problem,
+    /// please file an issue to let me know what domain needs millisecond
+    /// precision over billions of years, I'm curious.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_milli(0, 0, 1, 444);
+    /// assert_eq!(dt.timestamp_millis(), 1_444);
+    ///
+    /// let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms_milli(1, 46, 40, 555);
+    /// assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);
+    ///
+    /// let dt = NaiveDate::from_ymd(1969, 12, 31).and_hms_milli(23, 59, 59, 100);
+    /// assert_eq!(dt.timestamp_millis(), -900);
+    /// ~~~~
+    #[inline]
+    pub fn timestamp_millis(&self) -> i64 {
+        let as_ms = self.timestamp() * 1000;
+        as_ms + i64::from(self.timestamp_subsec_millis())
+    }
+
+    /// Returns the number of non-leap *nanoseconds* since midnight on January 1, 1970.
+    ///
+    /// Note that this does *not* account for the timezone!
+    /// The true "UNIX timestamp" would count seconds since the midnight *UTC* on the epoch.
+    ///
+    /// # Panics
+    ///
+    /// Note also that this does reduce the number of years that can be
+    /// represented from ~584 Billion to ~584 years. The dates that can be
+    /// represented as nanoseconds are between 1677-09-21T00:12:44.0 and
+    /// 2262-04-11T23:47:16.854775804.
+    ///
+    /// (If this is a problem, please file an issue to let me know what domain
+    /// needs nanosecond precision over millennia, I'm curious.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime};
+    ///
+    /// let dt = NaiveDate::from_ymd(1970, 1, 1).and_hms_nano(0, 0, 1, 444);
+    /// assert_eq!(dt.timestamp_nanos(), 1_000_000_444);
+    ///
+    /// let dt = NaiveDate::from_ymd(2001, 9, 9).and_hms_nano(1, 46, 40, 555);
+    ///
+    /// const A_BILLION: i64 = 1_000_000_000;
+    /// let nanos = dt.timestamp_nanos();
+    /// assert_eq!(nanos, 1_000_000_000_000_000_555);
+    /// assert_eq!(
+    ///     dt,
+    ///     NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32)
+    /// );
+    /// ~~~~
+    #[inline]
+    pub fn timestamp_nanos(&self) -> i64 {
+        let as_ns = self.timestamp() * 1_000_000_000;
+        as_ns + i64::from(self.timestamp_subsec_nanos())
+    }
+
+    /// Returns the number of milliseconds since the last whole non-leap second.
+    ///
+    /// The return value ranges from 0 to 999,
+    /// or for [leap seconds](./struct.NaiveTime.html#leap-second-handling), to 1,999.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789);
+    /// assert_eq!(dt.timestamp_subsec_millis(), 123);
+    ///
+    /// let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890);
+    /// assert_eq!(dt.timestamp_subsec_millis(), 1_234);
+    /// ~~~~
+    #[inline]
+    pub fn timestamp_subsec_millis(&self) -> u32 {
+        self.timestamp_subsec_nanos() / 1_000_000
+    }
+
+    /// Returns the number of microseconds since the last whole non-leap second.
+    ///
+    /// The return value ranges from 0 to 999,999,
+    /// or for [leap seconds](./struct.NaiveTime.html#leap-second-handling), to 1,999,999.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789);
+    /// assert_eq!(dt.timestamp_subsec_micros(), 123_456);
+    ///
+    /// let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890);
+    /// assert_eq!(dt.timestamp_subsec_micros(), 1_234_567);
+    /// ~~~~
+    #[inline]
+    pub fn timestamp_subsec_micros(&self) -> u32 {
+        self.timestamp_subsec_nanos() / 1_000
+    }
+
+    /// Returns the number of nanoseconds since the last whole non-leap second.
+    ///
+    /// The return value ranges from 0 to 999,999,999,
+    /// or for [leap seconds](./struct.NaiveTime.html#leap-second-handling), to 1,999,999,999.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_nano(9, 10, 11, 123_456_789);
+    /// assert_eq!(dt.timestamp_subsec_nanos(), 123_456_789);
+    ///
+    /// let dt = NaiveDate::from_ymd(2015, 7, 1).and_hms_nano(8, 59, 59, 1_234_567_890);
+    /// assert_eq!(dt.timestamp_subsec_nanos(), 1_234_567_890);
+    /// ~~~~
+    #[inline]
+    pub fn timestamp_subsec_nanos(&self) -> u32 {
+        self.time.nanosecond()
+    }
+
+    /// Adds given `Duration` to the current date and time.
+    ///
+    /// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
+    /// the addition assumes that **there is no leap second ever**,
+    /// except when the `NaiveDateTime` itself represents a leap second
+    /// in which case the assumption becomes that **there is exactly a single leap second ever**.
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveDate};
+    ///
+    /// let from_ymd = NaiveDate::from_ymd;
+    ///
+    /// let d = from_ymd(2016, 7, 8);
+    /// let hms = |h, m, s| d.and_hms(h, m, s);
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::zero()),
+    ///            Some(hms(3, 5, 7)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(1)),
+    ///            Some(hms(3, 5, 8)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(-1)),
+    ///            Some(hms(3, 5, 6)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(3600 + 60)),
+    ///            Some(hms(4, 6, 7)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::seconds(86_400)),
+    ///            Some(from_ymd(2016, 7, 9).and_hms(3, 5, 7)));
+    ///
+    /// let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
+    /// assert_eq!(hmsm(3, 5, 7, 980).checked_add_signed(Duration::milliseconds(450)),
+    ///            Some(hmsm(3, 5, 8, 430)));
+    /// # }
+    /// ~~~~
+    ///
+    /// Overflow returns `None`.
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// # use chrono::{Duration, NaiveDate};
+    /// # let hms = |h, m, s| NaiveDate::from_ymd(2016, 7, 8).and_hms(h, m, s);
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(Duration::days(1_000_000_000)), None);
+    /// # }
+    /// ~~~~
+    ///
+    /// Leap seconds are handled,
+    /// but the addition assumes that it is the only leap second happened.
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// # use chrono::{Duration, NaiveDate};
+    /// # let from_ymd = NaiveDate::from_ymd;
+    /// # let hmsm = |h, m, s, milli| from_ymd(2016, 7, 8).and_hms_milli(h, m, s, milli);
+    /// let leap = hmsm(3, 5, 59, 1_300);
+    /// assert_eq!(leap.checked_add_signed(Duration::zero()),
+    ///            Some(hmsm(3, 5, 59, 1_300)));
+    /// assert_eq!(leap.checked_add_signed(Duration::milliseconds(-500)),
+    ///            Some(hmsm(3, 5, 59, 800)));
+    /// assert_eq!(leap.checked_add_signed(Duration::milliseconds(500)),
+    ///            Some(hmsm(3, 5, 59, 1_800)));
+    /// assert_eq!(leap.checked_add_signed(Duration::milliseconds(800)),
+    ///            Some(hmsm(3, 6, 0, 100)));
+    /// assert_eq!(leap.checked_add_signed(Duration::seconds(10)),
+    ///            Some(hmsm(3, 6, 9, 300)));
+    /// assert_eq!(leap.checked_add_signed(Duration::seconds(-10)),
+    ///            Some(hmsm(3, 5, 50, 300)));
+    /// assert_eq!(leap.checked_add_signed(Duration::days(1)),
+    ///            Some(from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300)));
+    /// # }
+    /// ~~~~
+    pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDateTime> {
+        let (time, rhs) = self.time.overflowing_add_signed(rhs);
+
+        // early checking to avoid overflow in OldDuration::seconds
+        if rhs <= (-1 << MAX_SECS_BITS) || rhs >= (1 << MAX_SECS_BITS) {
+            return None;
+        }
+
+        let date = try_opt!(self.date.checked_add_signed(OldDuration::seconds(rhs)));
+        Some(NaiveDateTime { date: date, time: time })
+    }
+
+    /// Subtracts given `Duration` from the current date and time.
+    ///
+    /// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
+    /// the subtraction assumes that **there is no leap second ever**,
+    /// except when the `NaiveDateTime` itself represents a leap second
+    /// in which case the assumption becomes that **there is exactly a single leap second ever**.
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveDate};
+    ///
+    /// let from_ymd = NaiveDate::from_ymd;
+    ///
+    /// let d = from_ymd(2016, 7, 8);
+    /// let hms = |h, m, s| d.and_hms(h, m, s);
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::zero()),
+    ///            Some(hms(3, 5, 7)));
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(1)),
+    ///            Some(hms(3, 5, 6)));
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(-1)),
+    ///            Some(hms(3, 5, 8)));
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(3600 + 60)),
+    ///            Some(hms(2, 4, 7)));
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::seconds(86_400)),
+    ///            Some(from_ymd(2016, 7, 7).and_hms(3, 5, 7)));
+    ///
+    /// let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
+    /// assert_eq!(hmsm(3, 5, 7, 450).checked_sub_signed(Duration::milliseconds(670)),
+    ///            Some(hmsm(3, 5, 6, 780)));
+    /// # }
+    /// ~~~~
+    ///
+    /// Overflow returns `None`.
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// # use chrono::{Duration, NaiveDate};
+    /// # let hms = |h, m, s| NaiveDate::from_ymd(2016, 7, 8).and_hms(h, m, s);
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(Duration::days(1_000_000_000)), None);
+    /// # }
+    /// ~~~~
+    ///
+    /// Leap seconds are handled,
+    /// but the subtraction assumes that it is the only leap second happened.
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// # use chrono::{Duration, NaiveDate};
+    /// # let from_ymd = NaiveDate::from_ymd;
+    /// # let hmsm = |h, m, s, milli| from_ymd(2016, 7, 8).and_hms_milli(h, m, s, milli);
+    /// let leap = hmsm(3, 5, 59, 1_300);
+    /// assert_eq!(leap.checked_sub_signed(Duration::zero()),
+    ///            Some(hmsm(3, 5, 59, 1_300)));
+    /// assert_eq!(leap.checked_sub_signed(Duration::milliseconds(200)),
+    ///            Some(hmsm(3, 5, 59, 1_100)));
+    /// assert_eq!(leap.checked_sub_signed(Duration::milliseconds(500)),
+    ///            Some(hmsm(3, 5, 59, 800)));
+    /// assert_eq!(leap.checked_sub_signed(Duration::seconds(60)),
+    ///            Some(hmsm(3, 5, 0, 300)));
+    /// assert_eq!(leap.checked_sub_signed(Duration::days(1)),
+    ///            Some(from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300)));
+    /// # }
+    /// ~~~~
+    pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDateTime> {
+        let (time, rhs) = self.time.overflowing_sub_signed(rhs);
+
+        // early checking to avoid overflow in OldDuration::seconds
+        if rhs <= (-1 << MAX_SECS_BITS) || rhs >= (1 << MAX_SECS_BITS) {
+            return None;
+        }
+
+        let date = try_opt!(self.date.checked_sub_signed(OldDuration::seconds(rhs)));
+        Some(NaiveDateTime { date: date, time: time })
+    }
+
+    /// Subtracts another `NaiveDateTime` from the current date and time.
+    /// This does not overflow or underflow at all.
+    ///
+    /// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
+    /// the subtraction assumes that **there is no leap second ever**,
+    /// except when any of the `NaiveDateTime`s themselves represents a leap second
+    /// in which case the assumption becomes that
+    /// **there are exactly one (or two) leap second(s) ever**.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveDate};
+    ///
+    /// let from_ymd = NaiveDate::from_ymd;
+    ///
+    /// let d = from_ymd(2016, 7, 8);
+    /// assert_eq!(d.and_hms(3, 5, 7).signed_duration_since(d.and_hms(2, 4, 6)),
+    ///            Duration::seconds(3600 + 60 + 1));
+    ///
+    /// // July 8 is 190th day in the year 2016
+    /// let d0 = from_ymd(2016, 1, 1);
+    /// assert_eq!(d.and_hms_milli(0, 7, 6, 500).signed_duration_since(d0.and_hms(0, 0, 0)),
+    ///            Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));
+    /// # }
+    /// ~~~~
+    ///
+    /// Leap seconds are handled, but the subtraction assumes that
+    /// there were no other leap seconds happened.
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// # use chrono::{Duration, NaiveDate};
+    /// # let from_ymd = NaiveDate::from_ymd;
+    /// let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
+    /// assert_eq!(leap.signed_duration_since(from_ymd(2015, 6, 30).and_hms(23, 0, 0)),
+    ///            Duration::seconds(3600) + Duration::milliseconds(500));
+    /// assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0).signed_duration_since(leap),
+    ///            Duration::seconds(3600) - Duration::milliseconds(500));
+    /// # }
+    /// ~~~~
+    pub fn signed_duration_since(self, rhs: NaiveDateTime) -> OldDuration {
+        self.date.signed_duration_since(rhs.date) + self.time.signed_duration_since(rhs.time)
+    }
+
+    /// Formats the combined date and time with the specified formatting items.
+    /// Otherwise it is the same as the ordinary [`format`](#method.format) method.
+    ///
+    /// The `Iterator` of items should be `Clone`able,
+    /// since the resulting `DelayedFormat` value may be formatted multiple times.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    /// use chrono::format::strftime::StrftimeItems;
+    ///
+    /// let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S");
+    /// let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4);
+    /// assert_eq!(dt.format_with_items(fmt.clone()).to_string(), "2015-09-05 23:56:04");
+    /// assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(),    "2015-09-05 23:56:04");
+    /// ~~~~
+    ///
+    /// The resulting `DelayedFormat` can be formatted directly via the `Display` trait.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # use chrono::format::strftime::StrftimeItems;
+    /// # let fmt = StrftimeItems::new("%Y-%m-%d %H:%M:%S").clone();
+    /// # let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4);
+    /// assert_eq!(format!("{}", dt.format_with_items(fmt)), "2015-09-05 23:56:04");
+    /// ~~~~
+    #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
+    pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
+    where
+        I: Iterator<Item = B> + Clone,
+        B: Borrow<Item<'a>>,
+    {
+        DelayedFormat::new(Some(self.date), Some(self.time), items)
+    }
+
+    /// Formats the combined date and time with the specified format string.
+    /// See the [`format::strftime` module](../format/strftime/index.html)
+    /// on the supported escape sequences.
+    ///
+    /// This returns a `DelayedFormat`,
+    /// which gets converted to a string only when actual formatting happens.
+    /// You may use the `to_string` method to get a `String`,
+    /// or just feed it into `print!` and other formatting macros.
+    /// (In this way it avoids the redundant memory allocation.)
+    ///
+    /// A wrong format string does *not* issue an error immediately.
+    /// Rather, converting or formatting the `DelayedFormat` fails.
+    /// You are recommended to immediately use `DelayedFormat` for this reason.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveDate;
+    ///
+    /// let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4);
+    /// assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2015-09-05 23:56:04");
+    /// assert_eq!(dt.format("around %l %p on %b %-d").to_string(), "around 11 PM on Sep 5");
+    /// ~~~~
+    ///
+    /// The resulting `DelayedFormat` can be formatted directly via the `Display` trait.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveDate;
+    /// # let dt = NaiveDate::from_ymd(2015, 9, 5).and_hms(23, 56, 4);
+    /// assert_eq!(format!("{}", dt.format("%Y-%m-%d %H:%M:%S")), "2015-09-05 23:56:04");
+    /// assert_eq!(format!("{}", dt.format("around %l %p on %b %-d")), "around 11 PM on Sep 5");
+    /// ~~~~
+    #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
+    pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
+        self.format_with_items(StrftimeItems::new(fmt))
+    }
+}
+
+impl Datelike for NaiveDateTime {
+    /// Returns the year number in the [calendar date](./index.html#calendar-date).
+    ///
+    /// See also the [`NaiveDate::year`](./struct.NaiveDate.html#method.year) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.year(), 2015);
+    /// ~~~~
+    #[inline]
+    fn year(&self) -> i32 {
+        self.date.year()
+    }
+
+    /// Returns the month number starting from 1.
+    ///
+    /// The return value ranges from 1 to 12.
+    ///
+    /// See also the [`NaiveDate::month`](./struct.NaiveDate.html#method.month) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.month(), 9);
+    /// ~~~~
+    #[inline]
+    fn month(&self) -> u32 {
+        self.date.month()
+    }
+
+    /// Returns the month number starting from 0.
+    ///
+    /// The return value ranges from 0 to 11.
+    ///
+    /// See also the [`NaiveDate::month0`](./struct.NaiveDate.html#method.month0) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.month0(), 8);
+    /// ~~~~
+    #[inline]
+    fn month0(&self) -> u32 {
+        self.date.month0()
+    }
+
+    /// Returns the day of month starting from 1.
+    ///
+    /// The return value ranges from 1 to 31. (The last day of month differs by months.)
+    ///
+    /// See also the [`NaiveDate::day`](./struct.NaiveDate.html#method.day) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.day(), 25);
+    /// ~~~~
+    #[inline]
+    fn day(&self) -> u32 {
+        self.date.day()
+    }
+
+    /// Returns the day of month starting from 0.
+    ///
+    /// The return value ranges from 0 to 30. (The last day of month differs by months.)
+    ///
+    /// See also the [`NaiveDate::day0`](./struct.NaiveDate.html#method.day0) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.day0(), 24);
+    /// ~~~~
+    #[inline]
+    fn day0(&self) -> u32 {
+        self.date.day0()
+    }
+
+    /// Returns the day of year starting from 1.
+    ///
+    /// The return value ranges from 1 to 366. (The last day of year differs by years.)
+    ///
+    /// See also the [`NaiveDate::ordinal`](./struct.NaiveDate.html#method.ordinal) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.ordinal(), 268);
+    /// ~~~~
+    #[inline]
+    fn ordinal(&self) -> u32 {
+        self.date.ordinal()
+    }
+
+    /// Returns the day of year starting from 0.
+    ///
+    /// The return value ranges from 0 to 365. (The last day of year differs by years.)
+    ///
+    /// See also the [`NaiveDate::ordinal0`](./struct.NaiveDate.html#method.ordinal0) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.ordinal0(), 267);
+    /// ~~~~
+    #[inline]
+    fn ordinal0(&self) -> u32 {
+        self.date.ordinal0()
+    }
+
+    /// Returns the day of week.
+    ///
+    /// See also the [`NaiveDate::weekday`](./struct.NaiveDate.html#method.weekday) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike, Weekday};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.weekday(), Weekday::Fri);
+    /// ~~~~
+    #[inline]
+    fn weekday(&self) -> Weekday {
+        self.date.weekday()
+    }
+
+    #[inline]
+    fn iso_week(&self) -> IsoWeek {
+        self.date.iso_week()
+    }
+
+    /// Makes a new `NaiveDateTime` with the year number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_year`](./struct.NaiveDate.html#method.with_year) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 25).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_year(2016), Some(NaiveDate::from_ymd(2016, 9, 25).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_year(-308), Some(NaiveDate::from_ymd(-308, 9, 25).and_hms(12, 34, 56)));
+    /// ~~~~
+    #[inline]
+    fn with_year(&self, year: i32) -> Option<NaiveDateTime> {
+        self.date.with_year(year).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the month number (starting from 1) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_month`](./struct.NaiveDate.html#method.with_month) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_month(10), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_month(13), None); // no month 13
+    /// assert_eq!(dt.with_month(2), None); // no February 30
+    /// ~~~~
+    #[inline]
+    fn with_month(&self, month: u32) -> Option<NaiveDateTime> {
+        self.date.with_month(month).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the month number (starting from 0) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_month0`](./struct.NaiveDate.html#method.with_month0) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_month0(9), Some(NaiveDate::from_ymd(2015, 10, 30).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_month0(12), None); // no month 13
+    /// assert_eq!(dt.with_month0(1), None); // no February 30
+    /// ~~~~
+    #[inline]
+    fn with_month0(&self, month0: u32) -> Option<NaiveDateTime> {
+        self.date.with_month0(month0).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the day of month (starting from 1) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_day`](./struct.NaiveDate.html#method.with_day) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_day(30), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_day(31), None); // no September 31
+    /// ~~~~
+    #[inline]
+    fn with_day(&self, day: u32) -> Option<NaiveDateTime> {
+        self.date.with_day(day).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the day of month (starting from 0) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_day0`](./struct.NaiveDate.html#method.with_day0) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_day0(29), Some(NaiveDate::from_ymd(2015, 9, 30).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_day0(30), None); // no September 31
+    /// ~~~~
+    #[inline]
+    fn with_day0(&self, day0: u32) -> Option<NaiveDateTime> {
+        self.date.with_day0(day0).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the day of year (starting from 1) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_ordinal`](./struct.NaiveDate.html#method.with_ordinal) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_ordinal(60),
+    ///            Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_ordinal(366), None); // 2015 had only 365 days
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_ordinal(60),
+    ///            Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_ordinal(366),
+    ///            Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
+    /// ~~~~
+    #[inline]
+    fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDateTime> {
+        self.date.with_ordinal(ordinal).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the day of year (starting from 0) changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveDate::with_ordinal0`](./struct.NaiveDate.html#method.with_ordinal0) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Datelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_ordinal0(59),
+    ///            Some(NaiveDate::from_ymd(2015, 3, 1).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_ordinal0(365), None); // 2015 had only 365 days
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2016, 9, 8).and_hms(12, 34, 56);
+    /// assert_eq!(dt.with_ordinal0(59),
+    ///            Some(NaiveDate::from_ymd(2016, 2, 29).and_hms(12, 34, 56)));
+    /// assert_eq!(dt.with_ordinal0(365),
+    ///            Some(NaiveDate::from_ymd(2016, 12, 31).and_hms(12, 34, 56)));
+    /// ~~~~
+    #[inline]
+    fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDateTime> {
+        self.date.with_ordinal0(ordinal0).map(|d| NaiveDateTime { date: d, ..*self })
+    }
+}
+
+impl Timelike for NaiveDateTime {
+    /// Returns the hour number from 0 to 23.
+    ///
+    /// See also the [`NaiveTime::hour`](./struct.NaiveTime.html#method.hour) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.hour(), 12);
+    /// ~~~~
+    #[inline]
+    fn hour(&self) -> u32 {
+        self.time.hour()
+    }
+
+    /// Returns the minute number from 0 to 59.
+    ///
+    /// See also the [`NaiveTime::minute`](./struct.NaiveTime.html#method.minute) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.minute(), 34);
+    /// ~~~~
+    #[inline]
+    fn minute(&self) -> u32 {
+        self.time.minute()
+    }
+
+    /// Returns the second number from 0 to 59.
+    ///
+    /// See also the [`NaiveTime::second`](./struct.NaiveTime.html#method.second) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.second(), 56);
+    /// ~~~~
+    #[inline]
+    fn second(&self) -> u32 {
+        self.time.second()
+    }
+
+    /// Returns the number of nanoseconds since the whole non-leap second.
+    /// The range from 1,000,000,000 to 1,999,999,999 represents
+    /// the [leap second](./struct.NaiveTime.html#leap-second-handling).
+    ///
+    /// See also the
+    /// [`NaiveTime::nanosecond`](./struct.NaiveTime.html#method.nanosecond) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.nanosecond(), 789_000_000);
+    /// ~~~~
+    #[inline]
+    fn nanosecond(&self) -> u32 {
+        self.time.nanosecond()
+    }
+
+    /// Makes a new `NaiveDateTime` with the hour number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveTime::with_hour`](./struct.NaiveTime.html#method.with_hour) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.with_hour(7),
+    ///            Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(7, 34, 56, 789)));
+    /// assert_eq!(dt.with_hour(24), None);
+    /// ~~~~
+    #[inline]
+    fn with_hour(&self, hour: u32) -> Option<NaiveDateTime> {
+        self.time.with_hour(hour).map(|t| NaiveDateTime { time: t, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the minute number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    ///
+    /// See also the
+    /// [`NaiveTime::with_minute`](./struct.NaiveTime.html#method.with_minute) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.with_minute(45),
+    ///            Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 45, 56, 789)));
+    /// assert_eq!(dt.with_minute(60), None);
+    /// ~~~~
+    #[inline]
+    fn with_minute(&self, min: u32) -> Option<NaiveDateTime> {
+        self.time.with_minute(min).map(|t| NaiveDateTime { time: t, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with the second number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    /// As with the [`second`](#method.second) method,
+    /// the input range is restricted to 0 through 59.
+    ///
+    /// See also the
+    /// [`NaiveTime::with_second`](./struct.NaiveTime.html#method.with_second) method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.with_second(17),
+    ///            Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 17, 789)));
+    /// assert_eq!(dt.with_second(60), None);
+    /// ~~~~
+    #[inline]
+    fn with_second(&self, sec: u32) -> Option<NaiveDateTime> {
+        self.time.with_second(sec).map(|t| NaiveDateTime { time: t, ..*self })
+    }
+
+    /// Makes a new `NaiveDateTime` with nanoseconds since the whole non-leap second changed.
+    ///
+    /// Returns `None` when the resulting `NaiveDateTime` would be invalid.
+    /// As with the [`nanosecond`](#method.nanosecond) method,
+    /// the input range can exceed 1,000,000,000 for leap seconds.
+    ///
+    /// See also the
+    /// [`NaiveTime::with_nanosecond`](./struct.NaiveTime.html#method.with_nanosecond)
+    /// method.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    ///
+    /// let dt: NaiveDateTime = NaiveDate::from_ymd(2015, 9, 8).and_hms_milli(12, 34, 56, 789);
+    /// assert_eq!(dt.with_nanosecond(333_333_333),
+    ///            Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 333_333_333)));
+    /// assert_eq!(dt.with_nanosecond(1_333_333_333), // leap second
+    ///            Some(NaiveDate::from_ymd(2015, 9, 8).and_hms_nano(12, 34, 56, 1_333_333_333)));
+    /// assert_eq!(dt.with_nanosecond(2_000_000_000), None);
+    /// ~~~~
+    #[inline]
+    fn with_nanosecond(&self, nano: u32) -> Option<NaiveDateTime> {
+        self.time.with_nanosecond(nano).map(|t| NaiveDateTime { time: t, ..*self })
+    }
+}
+
+/// `NaiveDateTime` can be used as a key to the hash maps (in principle).
+///
+/// Practically this also takes account of fractional seconds, so it is not recommended.
+/// (For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
+impl hash::Hash for NaiveDateTime {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.date.hash(state);
+        self.time.hash(state);
+    }
+}
+
+/// An addition of `Duration` to `NaiveDateTime` yields another `NaiveDateTime`.
+///
+/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
+/// the addition assumes that **there is no leap second ever**,
+/// except when the `NaiveDateTime` itself represents a leap second
+/// in which case the assumption becomes that **there is exactly a single leap second ever**.
+///
+/// Panics on underflow or overflow.
+/// Use [`NaiveDateTime::checked_add_signed`](#method.checked_add_signed) to detect that.
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveDate};
+///
+/// let from_ymd = NaiveDate::from_ymd;
+///
+/// let d = from_ymd(2016, 7, 8);
+/// let hms = |h, m, s| d.and_hms(h, m, s);
+/// assert_eq!(hms(3, 5, 7) + Duration::zero(),             hms(3, 5, 7));
+/// assert_eq!(hms(3, 5, 7) + Duration::seconds(1),         hms(3, 5, 8));
+/// assert_eq!(hms(3, 5, 7) + Duration::seconds(-1),        hms(3, 5, 6));
+/// assert_eq!(hms(3, 5, 7) + Duration::seconds(3600 + 60), hms(4, 6, 7));
+/// assert_eq!(hms(3, 5, 7) + Duration::seconds(86_400),
+///            from_ymd(2016, 7, 9).and_hms(3, 5, 7));
+/// assert_eq!(hms(3, 5, 7) + Duration::days(365),
+///            from_ymd(2017, 7, 8).and_hms(3, 5, 7));
+///
+/// let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
+/// assert_eq!(hmsm(3, 5, 7, 980) + Duration::milliseconds(450), hmsm(3, 5, 8, 430));
+/// # }
+/// ~~~~
+///
+/// Leap seconds are handled,
+/// but the addition assumes that it is the only leap second happened.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveDate};
+/// # let from_ymd = NaiveDate::from_ymd;
+/// # let hmsm = |h, m, s, milli| from_ymd(2016, 7, 8).and_hms_milli(h, m, s, milli);
+/// let leap = hmsm(3, 5, 59, 1_300);
+/// assert_eq!(leap + Duration::zero(),             hmsm(3, 5, 59, 1_300));
+/// assert_eq!(leap + Duration::milliseconds(-500), hmsm(3, 5, 59, 800));
+/// assert_eq!(leap + Duration::milliseconds(500),  hmsm(3, 5, 59, 1_800));
+/// assert_eq!(leap + Duration::milliseconds(800),  hmsm(3, 6, 0, 100));
+/// assert_eq!(leap + Duration::seconds(10),        hmsm(3, 6, 9, 300));
+/// assert_eq!(leap + Duration::seconds(-10),       hmsm(3, 5, 50, 300));
+/// assert_eq!(leap + Duration::days(1),
+///            from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300));
+/// # }
+/// ~~~~
+impl Add<OldDuration> for NaiveDateTime {
+    type Output = NaiveDateTime;
+
+    #[inline]
+    fn add(self, rhs: OldDuration) -> NaiveDateTime {
+        self.checked_add_signed(rhs).expect("`NaiveDateTime + Duration` overflowed")
+    }
+}
+
+impl AddAssign<OldDuration> for NaiveDateTime {
+    #[inline]
+    fn add_assign(&mut self, rhs: OldDuration) {
+        *self = self.add(rhs);
+    }
+}
+
+/// A subtraction of `Duration` from `NaiveDateTime` yields another `NaiveDateTime`.
+/// It is the same as the addition with a negated `Duration`.
+///
+/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
+/// the addition assumes that **there is no leap second ever**,
+/// except when the `NaiveDateTime` itself represents a leap second
+/// in which case the assumption becomes that **there is exactly a single leap second ever**.
+///
+/// Panics on underflow or overflow.
+/// Use [`NaiveDateTime::checked_sub_signed`](#method.checked_sub_signed) to detect that.
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveDate};
+///
+/// let from_ymd = NaiveDate::from_ymd;
+///
+/// let d = from_ymd(2016, 7, 8);
+/// let hms = |h, m, s| d.and_hms(h, m, s);
+/// assert_eq!(hms(3, 5, 7) - Duration::zero(),             hms(3, 5, 7));
+/// assert_eq!(hms(3, 5, 7) - Duration::seconds(1),         hms(3, 5, 6));
+/// assert_eq!(hms(3, 5, 7) - Duration::seconds(-1),        hms(3, 5, 8));
+/// assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7));
+/// assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400),
+///            from_ymd(2016, 7, 7).and_hms(3, 5, 7));
+/// assert_eq!(hms(3, 5, 7) - Duration::days(365),
+///            from_ymd(2015, 7, 9).and_hms(3, 5, 7));
+///
+/// let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
+/// assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));
+/// # }
+/// ~~~~
+///
+/// Leap seconds are handled,
+/// but the subtraction assumes that it is the only leap second happened.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveDate};
+/// # let from_ymd = NaiveDate::from_ymd;
+/// # let hmsm = |h, m, s, milli| from_ymd(2016, 7, 8).and_hms_milli(h, m, s, milli);
+/// let leap = hmsm(3, 5, 59, 1_300);
+/// assert_eq!(leap - Duration::zero(),            hmsm(3, 5, 59, 1_300));
+/// assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100));
+/// assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800));
+/// assert_eq!(leap - Duration::seconds(60),       hmsm(3, 5, 0, 300));
+/// assert_eq!(leap - Duration::days(1),
+///            from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300));
+/// # }
+/// ~~~~
+impl Sub<OldDuration> for NaiveDateTime {
+    type Output = NaiveDateTime;
+
+    #[inline]
+    fn sub(self, rhs: OldDuration) -> NaiveDateTime {
+        self.checked_sub_signed(rhs).expect("`NaiveDateTime - Duration` overflowed")
+    }
+}
+
+impl SubAssign<OldDuration> for NaiveDateTime {
+    #[inline]
+    fn sub_assign(&mut self, rhs: OldDuration) {
+        *self = self.sub(rhs);
+    }
+}
+
+/// Subtracts another `NaiveDateTime` from the current date and time.
+/// This does not overflow or underflow at all.
+///
+/// As a part of Chrono's [leap second handling](./struct.NaiveTime.html#leap-second-handling),
+/// the subtraction assumes that **there is no leap second ever**,
+/// except when any of the `NaiveDateTime`s themselves represents a leap second
+/// in which case the assumption becomes that
+/// **there are exactly one (or two) leap second(s) ever**.
+///
+/// The implementation is a wrapper around
+/// [`NaiveDateTime::signed_duration_since`](#method.signed_duration_since).
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveDate};
+///
+/// let from_ymd = NaiveDate::from_ymd;
+///
+/// let d = from_ymd(2016, 7, 8);
+/// assert_eq!(d.and_hms(3, 5, 7) - d.and_hms(2, 4, 6), Duration::seconds(3600 + 60 + 1));
+///
+/// // July 8 is 190th day in the year 2016
+/// let d0 = from_ymd(2016, 1, 1);
+/// assert_eq!(d.and_hms_milli(0, 7, 6, 500) - d0.and_hms(0, 0, 0),
+///            Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));
+/// # }
+/// ~~~~
+///
+/// Leap seconds are handled, but the subtraction assumes that
+/// there were no other leap seconds happened.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveDate};
+/// # let from_ymd = NaiveDate::from_ymd;
+/// let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
+/// assert_eq!(leap - from_ymd(2015, 6, 30).and_hms(23, 0, 0),
+///            Duration::seconds(3600) + Duration::milliseconds(500));
+/// assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0) - leap,
+///            Duration::seconds(3600) - Duration::milliseconds(500));
+/// # }
+/// ~~~~
+impl Sub<NaiveDateTime> for NaiveDateTime {
+    type Output = OldDuration;
+
+    #[inline]
+    fn sub(self, rhs: NaiveDateTime) -> OldDuration {
+        self.signed_duration_since(rhs)
+    }
+}
+
+/// The `Debug` output of the naive date and time `dt` is the same as
+/// [`dt.format("%Y-%m-%dT%H:%M:%S%.f")`](../format/strftime/index.html).
+///
+/// The string printed can be readily parsed via the `parse` method on `str`.
+///
+/// It should be noted that, for leap seconds not on the minute boundary,
+/// it may print a representation not distinguishable from non-leap seconds.
+/// This doesn't matter in practice, since such leap seconds never happened.
+/// (By the time of the first leap second on 1972-06-30,
+/// every time zone offset around the world has standardized to the 5-minute alignment.)
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveDate;
+///
+/// let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
+/// assert_eq!(format!("{:?}", dt), "2016-11-15T07:39:24");
+/// ~~~~
+///
+/// Leap seconds may also be used.
+///
+/// ~~~~
+/// # use chrono::NaiveDate;
+/// let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
+/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60.500");
+/// ~~~~
+impl fmt::Debug for NaiveDateTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}T{:?}", self.date, self.time)
+    }
+}
+
+/// The `Display` output of the naive date and time `dt` is the same as
+/// [`dt.format("%Y-%m-%d %H:%M:%S%.f")`](../format/strftime/index.html).
+///
+/// It should be noted that, for leap seconds not on the minute boundary,
+/// it may print a representation not distinguishable from non-leap seconds.
+/// This doesn't matter in practice, since such leap seconds never happened.
+/// (By the time of the first leap second on 1972-06-30,
+/// every time zone offset around the world has standardized to the 5-minute alignment.)
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveDate;
+///
+/// let dt = NaiveDate::from_ymd(2016, 11, 15).and_hms(7, 39, 24);
+/// assert_eq!(format!("{}", dt), "2016-11-15 07:39:24");
+/// ~~~~
+///
+/// Leap seconds may also be used.
+///
+/// ~~~~
+/// # use chrono::NaiveDate;
+/// let dt = NaiveDate::from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
+/// assert_eq!(format!("{}", dt), "2015-06-30 23:59:60.500");
+/// ~~~~
+impl fmt::Display for NaiveDateTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} {}", self.date, self.time)
+    }
+}
+
+/// Parsing a `str` into a `NaiveDateTime` uses the same format,
+/// [`%Y-%m-%dT%H:%M:%S%.f`](../format/strftime/index.html), as in `Debug`.
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::{NaiveDateTime, NaiveDate};
+///
+/// let dt = NaiveDate::from_ymd(2015, 9, 18).and_hms(23, 56, 4);
+/// assert_eq!("2015-09-18T23:56:04".parse::<NaiveDateTime>(), Ok(dt));
+///
+/// let dt = NaiveDate::from_ymd(12345, 6, 7).and_hms_milli(7, 59, 59, 1_500); // leap second
+/// assert_eq!("+12345-6-7T7:59:60.5".parse::<NaiveDateTime>(), Ok(dt));
+///
+/// assert!("foo".parse::<NaiveDateTime>().is_err());
+/// ~~~~
+impl str::FromStr for NaiveDateTime {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> ParseResult<NaiveDateTime> {
+        const ITEMS: &'static [Item<'static>] = &[
+            Item::Numeric(Numeric::Year, Pad::Zero),
+            Item::Space(""),
+            Item::Literal("-"),
+            Item::Numeric(Numeric::Month, Pad::Zero),
+            Item::Space(""),
+            Item::Literal("-"),
+            Item::Numeric(Numeric::Day, Pad::Zero),
+            Item::Space(""),
+            Item::Literal("T"), // XXX shouldn't this be case-insensitive?
+            Item::Numeric(Numeric::Hour, Pad::Zero),
+            Item::Space(""),
+            Item::Literal(":"),
+            Item::Numeric(Numeric::Minute, Pad::Zero),
+            Item::Space(""),
+            Item::Literal(":"),
+            Item::Numeric(Numeric::Second, Pad::Zero),
+            Item::Fixed(Fixed::Nanosecond),
+            Item::Space(""),
+        ];
+
+        let mut parsed = Parsed::new();
+        parse(&mut parsed, s, ITEMS.iter())?;
+        parsed.to_naive_datetime_with_offset(0)
+    }
+}
+
+#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))]
+fn test_encodable_json<F, E>(to_string: F)
+where
+    F: Fn(&NaiveDateTime) -> Result<String, E>,
+    E: ::std::fmt::Debug,
+{
+    use naive::{MAX_DATE, MIN_DATE};
+
+    assert_eq!(
+        to_string(&NaiveDate::from_ymd(2016, 7, 8).and_hms_milli(9, 10, 48, 90)).ok(),
+        Some(r#""2016-07-08T09:10:48.090""#.into())
+    );
+    assert_eq!(
+        to_string(&NaiveDate::from_ymd(2014, 7, 24).and_hms(12, 34, 6)).ok(),
+        Some(r#""2014-07-24T12:34:06""#.into())
+    );
+    assert_eq!(
+        to_string(&NaiveDate::from_ymd(0, 1, 1).and_hms_milli(0, 0, 59, 1_000)).ok(),
+        Some(r#""0000-01-01T00:00:60""#.into())
+    );
+    assert_eq!(
+        to_string(&NaiveDate::from_ymd(-1, 12, 31).and_hms_nano(23, 59, 59, 7)).ok(),
+        Some(r#""-0001-12-31T23:59:59.000000007""#.into())
+    );
+    assert_eq!(
+        to_string(&MIN_DATE.and_hms(0, 0, 0)).ok(),
+        Some(r#""-262144-01-01T00:00:00""#.into())
+    );
+    assert_eq!(
+        to_string(&MAX_DATE.and_hms_nano(23, 59, 59, 1_999_999_999)).ok(),
+        Some(r#""+262143-12-31T23:59:60.999999999""#.into())
+    );
+}
+
+#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))]
+fn test_decodable_json<F, E>(from_str: F)
+where
+    F: Fn(&str) -> Result<NaiveDateTime, E>,
+    E: ::std::fmt::Debug,
+{
+    use naive::{MAX_DATE, MIN_DATE};
+
+    assert_eq!(
+        from_str(r#""2016-07-08T09:10:48.090""#).ok(),
+        Some(NaiveDate::from_ymd(2016, 7, 8).and_hms_milli(9, 10, 48, 90))
+    );
+    assert_eq!(
+        from_str(r#""2016-7-8T9:10:48.09""#).ok(),
+        Some(NaiveDate::from_ymd(2016, 7, 8).and_hms_milli(9, 10, 48, 90))
+    );
+    assert_eq!(
+        from_str(r#""2014-07-24T12:34:06""#).ok(),
+        Some(NaiveDate::from_ymd(2014, 7, 24).and_hms(12, 34, 6))
+    );
+    assert_eq!(
+        from_str(r#""0000-01-01T00:00:60""#).ok(),
+        Some(NaiveDate::from_ymd(0, 1, 1).and_hms_milli(0, 0, 59, 1_000))
+    );
+    assert_eq!(
+        from_str(r#""0-1-1T0:0:60""#).ok(),
+        Some(NaiveDate::from_ymd(0, 1, 1).and_hms_milli(0, 0, 59, 1_000))
+    );
+    assert_eq!(
+        from_str(r#""-0001-12-31T23:59:59.000000007""#).ok(),
+        Some(NaiveDate::from_ymd(-1, 12, 31).and_hms_nano(23, 59, 59, 7))
+    );
+    assert_eq!(from_str(r#""-262144-01-01T00:00:00""#).ok(), Some(MIN_DATE.and_hms(0, 0, 0)));
+    assert_eq!(
+        from_str(r#""+262143-12-31T23:59:60.999999999""#).ok(),
+        Some(MAX_DATE.and_hms_nano(23, 59, 59, 1_999_999_999))
+    );
+    assert_eq!(
+        from_str(r#""+262143-12-31T23:59:60.9999999999997""#).ok(), // excess digits are ignored
+        Some(MAX_DATE.and_hms_nano(23, 59, 59, 1_999_999_999))
+    );
+
+    // bad formats
+    assert!(from_str(r#""""#).is_err());
+    assert!(from_str(r#""2016-07-08""#).is_err());
+    assert!(from_str(r#""09:10:48.090""#).is_err());
+    assert!(from_str(r#""20160708T091048.090""#).is_err());
+    assert!(from_str(r#""2000-00-00T00:00:00""#).is_err());
+    assert!(from_str(r#""2000-02-30T00:00:00""#).is_err());
+    assert!(from_str(r#""2001-02-29T00:00:00""#).is_err());
+    assert!(from_str(r#""2002-02-28T24:00:00""#).is_err());
+    assert!(from_str(r#""2002-02-28T23:60:00""#).is_err());
+    assert!(from_str(r#""2002-02-28T23:59:61""#).is_err());
+    assert!(from_str(r#""2016-07-08T09:10:48,090""#).is_err());
+    assert!(from_str(r#""2016-07-08 09:10:48.090""#).is_err());
+    assert!(from_str(r#""2016-007-08T09:10:48.090""#).is_err());
+    assert!(from_str(r#""yyyy-mm-ddThh:mm:ss.fffffffff""#).is_err());
+    assert!(from_str(r#"20160708000000"#).is_err());
+    assert!(from_str(r#"{}"#).is_err());
+    // pre-0.3.0 rustc-serialize format is now invalid
+    assert!(from_str(r#"{"date":{"ymdf":20},"time":{"secs":0,"frac":0}}"#).is_err());
+    assert!(from_str(r#"null"#).is_err());
+}
+
+#[cfg(all(test, feature = "rustc-serialize"))]
+fn test_decodable_json_timestamp<F, E>(from_str: F)
+where
+    F: Fn(&str) -> Result<rustc_serialize::TsSeconds, E>,
+    E: ::std::fmt::Debug,
+{
+    assert_eq!(
+        *from_str("0").unwrap(),
+        NaiveDate::from_ymd(1970, 1, 1).and_hms(0, 0, 0),
+        "should parse integers as timestamps"
+    );
+    assert_eq!(
+        *from_str("-1").unwrap(),
+        NaiveDate::from_ymd(1969, 12, 31).and_hms(23, 59, 59),
+        "should parse integers as timestamps"
+    );
+}
+
+#[cfg(feature = "rustc-serialize")]
+pub mod rustc_serialize {
+    use super::NaiveDateTime;
+    use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+    use std::ops::Deref;
+
+    impl Encodable for NaiveDateTime {
+        fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+            format!("{:?}", self).encode(s)
+        }
+    }
+
+    impl Decodable for NaiveDateTime {
+        fn decode<D: Decoder>(d: &mut D) -> Result<NaiveDateTime, D::Error> {
+            d.read_str()?.parse().map_err(|_| d.error("invalid date time string"))
+        }
+    }
+
+    /// A `DateTime` that can be deserialized from a seconds-based timestamp
+    #[derive(Debug)]
+    #[deprecated(
+        since = "1.4.2",
+        note = "RustcSerialize will be removed before chrono 1.0, use Serde instead"
+    )]
+    pub struct TsSeconds(NaiveDateTime);
+
+    #[allow(deprecated)]
+    impl From<TsSeconds> for NaiveDateTime {
+        /// Pull the internal NaiveDateTime out
+        #[allow(deprecated)]
+        fn from(obj: TsSeconds) -> NaiveDateTime {
+            obj.0
+        }
+    }
+
+    #[allow(deprecated)]
+    impl Deref for TsSeconds {
+        type Target = NaiveDateTime;
+
+        #[allow(deprecated)]
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    #[allow(deprecated)]
+    impl Decodable for TsSeconds {
+        #[allow(deprecated)]
+        fn decode<D: Decoder>(d: &mut D) -> Result<TsSeconds, D::Error> {
+            Ok(TsSeconds(
+                NaiveDateTime::from_timestamp_opt(d.read_i64()?, 0)
+                    .ok_or_else(|| d.error("invalid timestamp"))?,
+            ))
+        }
+    }
+
+    #[cfg(test)]
+    use rustc_serialize::json;
+
+    #[test]
+    fn test_encodable() {
+        super::test_encodable_json(json::encode);
+    }
+
+    #[test]
+    fn test_decodable() {
+        super::test_decodable_json(json::decode);
+    }
+
+    #[test]
+    fn test_decodable_timestamps() {
+        super::test_decodable_json_timestamp(json::decode);
+    }
+}
+
+/// Tools to help serializing/deserializing `NaiveDateTime`s
+#[cfg(feature = "serde")]
+pub mod serde {
+    use super::NaiveDateTime;
+    use core::fmt;
+    use serdelib::{de, ser};
+
+    /// Serialize a `NaiveDateTime` as an RFC 3339 string
+    ///
+    /// See [the `serde` module](./serde/index.html) for alternate
+    /// serialization formats.
+    impl ser::Serialize for NaiveDateTime {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: ser::Serializer,
+        {
+            struct FormatWrapped<'a, D: 'a> {
+                inner: &'a D,
+            }
+
+            impl<'a, D: fmt::Debug> fmt::Display for FormatWrapped<'a, D> {
+                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    self.inner.fmt(f)
+                }
+            }
+
+            serializer.collect_str(&FormatWrapped { inner: &self })
+        }
+    }
+
+    struct NaiveDateTimeVisitor;
+
+    impl<'de> de::Visitor<'de> for NaiveDateTimeVisitor {
+        type Value = NaiveDateTime;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            write!(formatter, "a formatted date and time string")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<NaiveDateTime, E>
+        where
+            E: de::Error,
+        {
+            value.parse().map_err(E::custom)
+        }
+    }
+
+    impl<'de> de::Deserialize<'de> for NaiveDateTime {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            deserializer.deserialize_str(NaiveDateTimeVisitor)
+        }
+    }
+
+    /// Used to serialize/deserialize from nanosecond-precision timestamps
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # extern crate serde_json;
+    /// # extern crate serde;
+    /// # extern crate chrono;
+    /// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, Utc};
+    /// use chrono::naive::serde::ts_nanoseconds;
+    /// #[derive(Deserialize, Serialize)]
+    /// struct S {
+    ///     #[serde(with = "ts_nanoseconds")]
+    ///     time: NaiveDateTime
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let time = NaiveDate::from_ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733);
+    /// let my_s = S {
+    ///     time: time.clone(),
+    /// };
+    ///
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#);
+    /// let my_s: S = serde_json::from_str(&as_string)?;
+    /// assert_eq!(my_s.time, time);
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub mod ts_nanoseconds {
+        use core::fmt;
+        use serdelib::{de, ser};
+
+        use {ne_timestamp, NaiveDateTime};
+
+        /// Serialize a UTC datetime into an integer number of nanoseconds since the epoch
+        ///
+        /// Intended for use with `serde`s `serialize_with` attribute.
+        ///
+        /// # Example:
+        ///
+        /// ```rust
+        /// # // We mark this ignored so that we can test on 1.13 (which does not
+        /// # // support custom derive), and run tests with --ignored on beta and
+        /// # // nightly to actually trigger these.
+        /// #
+        /// # #[macro_use] extern crate serde_derive;
+        /// # #[macro_use] extern crate serde_json;
+        /// # #[macro_use] extern crate serde;
+        /// # extern crate chrono;
+        /// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, Utc};
+        /// # use serde::Serialize;
+        /// use chrono::naive::serde::ts_nanoseconds::serialize as to_nano_ts;
+        /// #[derive(Serialize)]
+        /// struct S {
+        ///     #[serde(serialize_with = "to_nano_ts")]
+        ///     time: NaiveDateTime
+        /// }
+        ///
+        /// # fn example() -> Result<String, serde_json::Error> {
+        /// let my_s = S {
+        ///     time: NaiveDate::from_ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733),
+        /// };
+        /// let as_string = serde_json::to_string(&my_s)?;
+        /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#);
+        /// # Ok(as_string)
+        /// # }
+        /// # fn main() { example().unwrap(); }
+        /// ```
+        pub fn serialize<S>(dt: &NaiveDateTime, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: ser::Serializer,
+        {
+            serializer.serialize_i64(dt.timestamp_nanos())
+        }
+
+        /// Deserialize a `DateTime` from a nanoseconds timestamp
+        ///
+        /// Intended for use with `serde`s `deserialize_with` attribute.
+        ///
+        /// # Example:
+        ///
+        /// ```rust
+        /// # // We mark this ignored so that we can test on 1.13 (which does not
+        /// # // support custom derive), and run tests with --ignored on beta and
+        /// # // nightly to actually trigger these.
+        /// #
+        /// # #[macro_use] extern crate serde_derive;
+        /// # #[macro_use] extern crate serde_json;
+        /// # extern crate serde;
+        /// # extern crate chrono;
+        /// # use chrono::{NaiveDateTime, Utc};
+        /// # use serde::Deserialize;
+        /// use chrono::naive::serde::ts_nanoseconds::deserialize as from_nano_ts;
+        /// #[derive(Deserialize)]
+        /// struct S {
+        ///     #[serde(deserialize_with = "from_nano_ts")]
+        ///     time: NaiveDateTime
+        /// }
+        ///
+        /// # fn example() -> Result<S, serde_json::Error> {
+        /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355733 }"#)?;
+        /// # Ok(my_s)
+        /// # }
+        /// # fn main() { example().unwrap(); }
+        /// ```
+        pub fn deserialize<'de, D>(d: D) -> Result<NaiveDateTime, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            Ok(d.deserialize_i64(NaiveDateTimeFromNanoSecondsVisitor)?)
+        }
+
+        struct NaiveDateTimeFromNanoSecondsVisitor;
+
+        impl<'de> de::Visitor<'de> for NaiveDateTimeFromNanoSecondsVisitor {
+            type Value = NaiveDateTime;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a unix timestamp")
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<NaiveDateTime, E>
+            where
+                E: de::Error,
+            {
+                NaiveDateTime::from_timestamp_opt(
+                    value / 1_000_000_000,
+                    (value % 1_000_000_000) as u32,
+                )
+                .ok_or_else(|| E::custom(ne_timestamp(value)))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<NaiveDateTime, E>
+            where
+                E: de::Error,
+            {
+                NaiveDateTime::from_timestamp_opt(
+                    value as i64 / 1_000_000_000,
+                    (value as i64 % 1_000_000_000) as u32,
+                )
+                .ok_or_else(|| E::custom(ne_timestamp(value)))
+            }
+        }
+    }
+
+    /// Used to serialize/deserialize from millisecond-precision timestamps
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # extern crate serde_json;
+    /// # extern crate serde;
+    /// # extern crate chrono;
+    /// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, Utc};
+    /// use chrono::naive::serde::ts_milliseconds;
+    /// #[derive(Deserialize, Serialize)]
+    /// struct S {
+    ///     #[serde(with = "ts_milliseconds")]
+    ///     time: NaiveDateTime
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let time = NaiveDate::from_ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918);
+    /// let my_s = S {
+    ///     time: time.clone(),
+    /// };
+    ///
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1526522699918}"#);
+    /// let my_s: S = serde_json::from_str(&as_string)?;
+    /// assert_eq!(my_s.time, time);
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub mod ts_milliseconds {
+        use core::fmt;
+        use serdelib::{de, ser};
+
+        use {ne_timestamp, NaiveDateTime};
+
+        /// Serialize a UTC datetime into an integer number of milliseconds since the epoch
+        ///
+        /// Intended for use with `serde`s `serialize_with` attribute.
+        ///
+        /// # Example:
+        ///
+        /// ```rust
+        /// # // We mark this ignored so that we can test on 1.13 (which does not
+        /// # // support custom derive), and run tests with --ignored on beta and
+        /// # // nightly to actually trigger these.
+        /// #
+        /// # #[macro_use] extern crate serde_derive;
+        /// # #[macro_use] extern crate serde_json;
+        /// # #[macro_use] extern crate serde;
+        /// # extern crate chrono;
+        /// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, Utc};
+        /// # use serde::Serialize;
+        /// use chrono::naive::serde::ts_milliseconds::serialize as to_milli_ts;
+        /// #[derive(Serialize)]
+        /// struct S {
+        ///     #[serde(serialize_with = "to_milli_ts")]
+        ///     time: NaiveDateTime
+        /// }
+        ///
+        /// # fn example() -> Result<String, serde_json::Error> {
+        /// let my_s = S {
+        ///     time: NaiveDate::from_ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918),
+        /// };
+        /// let as_string = serde_json::to_string(&my_s)?;
+        /// assert_eq!(as_string, r#"{"time":1526522699918}"#);
+        /// # Ok(as_string)
+        /// # }
+        /// # fn main() { example().unwrap(); }
+        /// ```
+        pub fn serialize<S>(dt: &NaiveDateTime, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: ser::Serializer,
+        {
+            serializer.serialize_i64(dt.timestamp_millis())
+        }
+
+        /// Deserialize a `DateTime` from a milliseconds timestamp
+        ///
+        /// Intended for use with `serde`s `deserialize_with` attribute.
+        ///
+        /// # Example:
+        ///
+        /// ```rust
+        /// # // We mark this ignored so that we can test on 1.13 (which does not
+        /// # // support custom derive), and run tests with --ignored on beta and
+        /// # // nightly to actually trigger these.
+        /// #
+        /// # #[macro_use] extern crate serde_derive;
+        /// # #[macro_use] extern crate serde_json;
+        /// # extern crate serde;
+        /// # extern crate chrono;
+        /// # use chrono::{NaiveDateTime, Utc};
+        /// # use serde::Deserialize;
+        /// use chrono::naive::serde::ts_milliseconds::deserialize as from_milli_ts;
+        /// #[derive(Deserialize)]
+        /// struct S {
+        ///     #[serde(deserialize_with = "from_milli_ts")]
+        ///     time: NaiveDateTime
+        /// }
+        ///
+        /// # fn example() -> Result<S, serde_json::Error> {
+        /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918 }"#)?;
+        /// # Ok(my_s)
+        /// # }
+        /// # fn main() { example().unwrap(); }
+        /// ```
+        pub fn deserialize<'de, D>(d: D) -> Result<NaiveDateTime, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            Ok(d.deserialize_i64(NaiveDateTimeFromMilliSecondsVisitor)?)
+        }
+
+        struct NaiveDateTimeFromMilliSecondsVisitor;
+
+        impl<'de> de::Visitor<'de> for NaiveDateTimeFromMilliSecondsVisitor {
+            type Value = NaiveDateTime;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a unix timestamp")
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<NaiveDateTime, E>
+            where
+                E: de::Error,
+            {
+                NaiveDateTime::from_timestamp_opt(value / 1000, ((value % 1000) * 1_000_000) as u32)
+                    .ok_or_else(|| E::custom(ne_timestamp(value)))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<NaiveDateTime, E>
+            where
+                E: de::Error,
+            {
+                NaiveDateTime::from_timestamp_opt(
+                    (value / 1000) as i64,
+                    ((value % 1000) * 1_000_000) as u32,
+                )
+                .ok_or_else(|| E::custom(ne_timestamp(value)))
+            }
+        }
+    }
+
+    /// Used to serialize/deserialize from second-precision timestamps
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # extern crate serde_json;
+    /// # extern crate serde;
+    /// # extern crate chrono;
+    /// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, Utc};
+    /// use chrono::naive::serde::ts_seconds;
+    /// #[derive(Deserialize, Serialize)]
+    /// struct S {
+    ///     #[serde(with = "ts_seconds")]
+    ///     time: NaiveDateTime
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let time = NaiveDate::from_ymd(2015, 5, 15).and_hms(10, 0, 0);
+    /// let my_s = S {
+    ///     time: time.clone(),
+    /// };
+    ///
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1431684000}"#);
+    /// let my_s: S = serde_json::from_str(&as_string)?;
+    /// assert_eq!(my_s.time, time);
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub mod ts_seconds {
+        use core::fmt;
+        use serdelib::{de, ser};
+
+        use {ne_timestamp, NaiveDateTime};
+
+        /// Serialize a UTC datetime into an integer number of seconds since the epoch
+        ///
+        /// Intended for use with `serde`s `serialize_with` attribute.
+        ///
+        /// # Example:
+        ///
+        /// ```rust
+        /// # // We mark this ignored so that we can test on 1.13 (which does not
+        /// # // support custom derive), and run tests with --ignored on beta and
+        /// # // nightly to actually trigger these.
+        /// #
+        /// # #[macro_use] extern crate serde_derive;
+        /// # #[macro_use] extern crate serde_json;
+        /// # #[macro_use] extern crate serde;
+        /// # extern crate chrono;
+        /// # use chrono::{TimeZone, NaiveDate, NaiveDateTime, Utc};
+        /// # use serde::Serialize;
+        /// use chrono::naive::serde::ts_seconds::serialize as to_ts;
+        /// #[derive(Serialize)]
+        /// struct S {
+        ///     #[serde(serialize_with = "to_ts")]
+        ///     time: NaiveDateTime
+        /// }
+        ///
+        /// # fn example() -> Result<String, serde_json::Error> {
+        /// let my_s = S {
+        ///     time: NaiveDate::from_ymd(2015, 5, 15).and_hms(10, 0, 0),
+        /// };
+        /// let as_string = serde_json::to_string(&my_s)?;
+        /// assert_eq!(as_string, r#"{"time":1431684000}"#);
+        /// # Ok(as_string)
+        /// # }
+        /// # fn main() { example().unwrap(); }
+        /// ```
+        pub fn serialize<S>(dt: &NaiveDateTime, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: ser::Serializer,
+        {
+            serializer.serialize_i64(dt.timestamp())
+        }
+
+        /// Deserialize a `DateTime` from a seconds timestamp
+        ///
+        /// Intended for use with `serde`s `deserialize_with` attribute.
+        ///
+        /// # Example:
+        ///
+        /// ```rust
+        /// # // We mark this ignored so that we can test on 1.13 (which does not
+        /// # // support custom derive), and run tests with --ignored on beta and
+        /// # // nightly to actually trigger these.
+        /// #
+        /// # #[macro_use] extern crate serde_derive;
+        /// # #[macro_use] extern crate serde_json;
+        /// # extern crate serde;
+        /// # extern crate chrono;
+        /// # use chrono::{NaiveDateTime, Utc};
+        /// # use serde::Deserialize;
+        /// use chrono::naive::serde::ts_seconds::deserialize as from_ts;
+        /// #[derive(Deserialize)]
+        /// struct S {
+        ///     #[serde(deserialize_with = "from_ts")]
+        ///     time: NaiveDateTime
+        /// }
+        ///
+        /// # fn example() -> Result<S, serde_json::Error> {
+        /// let my_s: S = serde_json::from_str(r#"{ "time": 1431684000 }"#)?;
+        /// # Ok(my_s)
+        /// # }
+        /// # fn main() { example().unwrap(); }
+        /// ```
+        pub fn deserialize<'de, D>(d: D) -> Result<NaiveDateTime, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            Ok(d.deserialize_i64(NaiveDateTimeFromSecondsVisitor)?)
+        }
+
+        struct NaiveDateTimeFromSecondsVisitor;
+
+        impl<'de> de::Visitor<'de> for NaiveDateTimeFromSecondsVisitor {
+            type Value = NaiveDateTime;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a unix timestamp")
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<NaiveDateTime, E>
+            where
+                E: de::Error,
+            {
+                NaiveDateTime::from_timestamp_opt(value, 0)
+                    .ok_or_else(|| E::custom(ne_timestamp(value)))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<NaiveDateTime, E>
+            where
+                E: de::Error,
+            {
+                NaiveDateTime::from_timestamp_opt(value as i64, 0)
+                    .ok_or_else(|| E::custom(ne_timestamp(value)))
+            }
+        }
+    }
+
+    #[cfg(test)]
+    extern crate bincode;
+    #[cfg(test)]
+    extern crate serde_derive;
+    #[cfg(test)]
+    extern crate serde_json;
+
+    #[test]
+    fn test_serde_serialize() {
+        super::test_encodable_json(self::serde_json::to_string);
+    }
+
+    #[test]
+    fn test_serde_deserialize() {
+        super::test_decodable_json(|input| self::serde_json::from_str(&input));
+    }
+
+    // Bincode is relevant to test separately from JSON because
+    // it is not self-describing.
+    #[test]
+    fn test_serde_bincode() {
+        use self::bincode::{deserialize, serialize, Infinite};
+        use naive::NaiveDate;
+
+        let dt = NaiveDate::from_ymd(2016, 7, 8).and_hms_milli(9, 10, 48, 90);
+        let encoded = serialize(&dt, Infinite).unwrap();
+        let decoded: NaiveDateTime = deserialize(&encoded).unwrap();
+        assert_eq!(dt, decoded);
+    }
+
+    #[test]
+    fn test_serde_bincode_optional() {
+        use self::bincode::{deserialize, serialize, Infinite};
+        use self::serde_derive::{Deserialize, Serialize};
+        use prelude::*;
+        use serde::ts_nanoseconds_option;
+
+        #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+        struct Test {
+            one: Option<i64>,
+            #[serde(with = "ts_nanoseconds_option")]
+            two: Option<DateTime<Utc>>,
+        }
+
+        let expected = Test { one: Some(1), two: Some(Utc.ymd(1970, 1, 1).and_hms(0, 1, 1)) };
+        let bytes: Vec<u8> = serialize(&expected, Infinite).unwrap();
+        let actual = deserialize::<Test>(&(bytes)).unwrap();
+
+        assert_eq!(expected, actual);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::NaiveDateTime;
+    use naive::{NaiveDate, MAX_DATE, MIN_DATE};
+    use oldtime::Duration;
+    use std::i64;
+    use Datelike;
+
+    #[test]
+    fn test_datetime_from_timestamp() {
+        let from_timestamp = |secs| NaiveDateTime::from_timestamp_opt(secs, 0);
+        let ymdhms = |y, m, d, h, n, s| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
+        assert_eq!(from_timestamp(-1), Some(ymdhms(1969, 12, 31, 23, 59, 59)));
+        assert_eq!(from_timestamp(0), Some(ymdhms(1970, 1, 1, 0, 0, 0)));
+        assert_eq!(from_timestamp(1), Some(ymdhms(1970, 1, 1, 0, 0, 1)));
+        assert_eq!(from_timestamp(1_000_000_000), Some(ymdhms(2001, 9, 9, 1, 46, 40)));
+        assert_eq!(from_timestamp(0x7fffffff), Some(ymdhms(2038, 1, 19, 3, 14, 7)));
+        assert_eq!(from_timestamp(i64::MIN), None);
+        assert_eq!(from_timestamp(i64::MAX), None);
+    }
+
+    #[test]
+    fn test_datetime_add() {
+        fn check(
+            (y, m, d, h, n, s): (i32, u32, u32, u32, u32, u32),
+            rhs: Duration,
+            result: Option<(i32, u32, u32, u32, u32, u32)>,
+        ) {
+            let lhs = NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
+            let sum =
+                result.map(|(y, m, d, h, n, s)| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s));
+            assert_eq!(lhs.checked_add_signed(rhs), sum);
+            assert_eq!(lhs.checked_sub_signed(-rhs), sum);
+        };
+
+        check(
+            (2014, 5, 6, 7, 8, 9),
+            Duration::seconds(3600 + 60 + 1),
+            Some((2014, 5, 6, 8, 9, 10)),
+        );
+        check(
+            (2014, 5, 6, 7, 8, 9),
+            Duration::seconds(-(3600 + 60 + 1)),
+            Some((2014, 5, 6, 6, 7, 8)),
+        );
+        check((2014, 5, 6, 7, 8, 9), Duration::seconds(86399), Some((2014, 5, 7, 7, 8, 8)));
+        check((2014, 5, 6, 7, 8, 9), Duration::seconds(86_400 * 10), Some((2014, 5, 16, 7, 8, 9)));
+        check((2014, 5, 6, 7, 8, 9), Duration::seconds(-86_400 * 10), Some((2014, 4, 26, 7, 8, 9)));
+        check((2014, 5, 6, 7, 8, 9), Duration::seconds(86_400 * 10), Some((2014, 5, 16, 7, 8, 9)));
+
+        // overflow check
+        // assumes that we have correct values for MAX/MIN_DAYS_FROM_YEAR_0 from `naive::date`.
+        // (they are private constants, but the equivalence is tested in that module.)
+        let max_days_from_year_0 = MAX_DATE.signed_duration_since(NaiveDate::from_ymd(0, 1, 1));
+        check((0, 1, 1, 0, 0, 0), max_days_from_year_0, Some((MAX_DATE.year(), 12, 31, 0, 0, 0)));
+        check(
+            (0, 1, 1, 0, 0, 0),
+            max_days_from_year_0 + Duration::seconds(86399),
+            Some((MAX_DATE.year(), 12, 31, 23, 59, 59)),
+        );
+        check((0, 1, 1, 0, 0, 0), max_days_from_year_0 + Duration::seconds(86_400), None);
+        check((0, 1, 1, 0, 0, 0), Duration::max_value(), None);
+
+        let min_days_from_year_0 = MIN_DATE.signed_duration_since(NaiveDate::from_ymd(0, 1, 1));
+        check((0, 1, 1, 0, 0, 0), min_days_from_year_0, Some((MIN_DATE.year(), 1, 1, 0, 0, 0)));
+        check((0, 1, 1, 0, 0, 0), min_days_from_year_0 - Duration::seconds(1), None);
+        check((0, 1, 1, 0, 0, 0), Duration::min_value(), None);
+    }
+
+    #[test]
+    fn test_datetime_sub() {
+        let ymdhms = |y, m, d, h, n, s| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
+        let since = NaiveDateTime::signed_duration_since;
+        assert_eq!(
+            since(ymdhms(2014, 5, 6, 7, 8, 9), ymdhms(2014, 5, 6, 7, 8, 9)),
+            Duration::zero()
+        );
+        assert_eq!(
+            since(ymdhms(2014, 5, 6, 7, 8, 10), ymdhms(2014, 5, 6, 7, 8, 9)),
+            Duration::seconds(1)
+        );
+        assert_eq!(
+            since(ymdhms(2014, 5, 6, 7, 8, 9), ymdhms(2014, 5, 6, 7, 8, 10)),
+            Duration::seconds(-1)
+        );
+        assert_eq!(
+            since(ymdhms(2014, 5, 7, 7, 8, 9), ymdhms(2014, 5, 6, 7, 8, 10)),
+            Duration::seconds(86399)
+        );
+        assert_eq!(
+            since(ymdhms(2001, 9, 9, 1, 46, 39), ymdhms(1970, 1, 1, 0, 0, 0)),
+            Duration::seconds(999_999_999)
+        );
+    }
+
+    #[test]
+    fn test_datetime_addassignment() {
+        let ymdhms = |y, m, d, h, n, s| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
+        let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+        date += Duration::minutes(10_000_000);
+        assert_eq!(date, ymdhms(2035, 10, 6, 20, 50, 10));
+        date += Duration::days(10);
+        assert_eq!(date, ymdhms(2035, 10, 16, 20, 50, 10));
+    }
+
+    #[test]
+    fn test_datetime_subassignment() {
+        let ymdhms = |y, m, d, h, n, s| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
+        let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+        date -= Duration::minutes(10_000_000);
+        assert_eq!(date, ymdhms(1997, 9, 26, 23, 30, 10));
+        date -= Duration::days(10);
+        assert_eq!(date, ymdhms(1997, 9, 16, 23, 30, 10));
+    }
+
+    #[test]
+    fn test_datetime_timestamp() {
+        let to_timestamp =
+            |y, m, d, h, n, s| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s).timestamp();
+        assert_eq!(to_timestamp(1969, 12, 31, 23, 59, 59), -1);
+        assert_eq!(to_timestamp(1970, 1, 1, 0, 0, 0), 0);
+        assert_eq!(to_timestamp(1970, 1, 1, 0, 0, 1), 1);
+        assert_eq!(to_timestamp(2001, 9, 9, 1, 46, 40), 1_000_000_000);
+        assert_eq!(to_timestamp(2038, 1, 19, 3, 14, 7), 0x7fffffff);
+    }
+
+    #[test]
+    fn test_datetime_from_str() {
+        // valid cases
+        let valid = [
+            "2015-2-18T23:16:9.15",
+            "-77-02-18T23:16:09",
+            "  +82701  -  05  -  6  T  15  :  9  : 60.898989898989   ",
+        ];
+        for &s in &valid {
+            let d = match s.parse::<NaiveDateTime>() {
+                Ok(d) => d,
+                Err(e) => panic!("parsing `{}` has failed: {}", s, e),
+            };
+            let s_ = format!("{:?}", d);
+            // `s` and `s_` may differ, but `s.parse()` and `s_.parse()` must be same
+            let d_ = match s_.parse::<NaiveDateTime>() {
+                Ok(d) => d,
+                Err(e) => {
+                    panic!("`{}` is parsed into `{:?}`, but reparsing that has failed: {}", s, d, e)
+                }
+            };
+            assert!(
+                d == d_,
+                "`{}` is parsed into `{:?}`, but reparsed result \
+                              `{:?}` does not match",
+                s,
+                d,
+                d_
+            );
+        }
+
+        // some invalid cases
+        // since `ParseErrorKind` is private, all we can do is to check if there was an error
+        assert!("".parse::<NaiveDateTime>().is_err());
+        assert!("x".parse::<NaiveDateTime>().is_err());
+        assert!("15".parse::<NaiveDateTime>().is_err());
+        assert!("15:8:9".parse::<NaiveDateTime>().is_err());
+        assert!("15-8-9".parse::<NaiveDateTime>().is_err());
+        assert!("2015-15-15T15:15:15".parse::<NaiveDateTime>().is_err());
+        assert!("2012-12-12T12:12:12x".parse::<NaiveDateTime>().is_err());
+        assert!("2012-123-12T12:12:12".parse::<NaiveDateTime>().is_err());
+        assert!("+ 82701-123-12T12:12:12".parse::<NaiveDateTime>().is_err());
+        assert!("+802701-123-12T12:12:12".parse::<NaiveDateTime>().is_err()); // out-of-bound
+    }
+
+    #[test]
+    fn test_datetime_parse_from_str() {
+        let ymdhms = |y, m, d, h, n, s| NaiveDate::from_ymd(y, m, d).and_hms(h, n, s);
+        let ymdhmsn =
+            |y, m, d, h, n, s, nano| NaiveDate::from_ymd(y, m, d).and_hms_nano(h, n, s, nano);
+        assert_eq!(
+            NaiveDateTime::parse_from_str("2014-5-7T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
+            Ok(ymdhms(2014, 5, 7, 12, 34, 56))
+        ); // ignore offset
+        assert_eq!(
+            NaiveDateTime::parse_from_str("2015-W06-1 000000", "%G-W%V-%u%H%M%S"),
+            Ok(ymdhms(2015, 2, 2, 0, 0, 0))
+        );
+        assert_eq!(
+            NaiveDateTime::parse_from_str(
+                "Fri, 09 Aug 2013 23:54:35 GMT",
+                "%a, %d %b %Y %H:%M:%S GMT"
+            ),
+            Ok(ymdhms(2013, 8, 9, 23, 54, 35))
+        );
+        assert!(NaiveDateTime::parse_from_str(
+            "Sat, 09 Aug 2013 23:54:35 GMT",
+            "%a, %d %b %Y %H:%M:%S GMT"
+        )
+        .is_err());
+        assert!(NaiveDateTime::parse_from_str("2014-5-7 12:3456", "%Y-%m-%d %H:%M:%S").is_err());
+        assert!(NaiveDateTime::parse_from_str("12:34:56", "%H:%M:%S").is_err()); // insufficient
+        assert_eq!(
+            NaiveDateTime::parse_from_str("1441497364", "%s"),
+            Ok(ymdhms(2015, 9, 5, 23, 56, 4))
+        );
+        assert_eq!(
+            NaiveDateTime::parse_from_str("1283929614.1234", "%s.%f"),
+            Ok(ymdhmsn(2010, 9, 8, 7, 6, 54, 1234))
+        );
+        assert_eq!(
+            NaiveDateTime::parse_from_str("1441497364.649", "%s%.3f"),
+            Ok(ymdhmsn(2015, 9, 5, 23, 56, 4, 649000000))
+        );
+        assert_eq!(
+            NaiveDateTime::parse_from_str("1497854303.087654", "%s%.6f"),
+            Ok(ymdhmsn(2017, 6, 19, 6, 38, 23, 87654000))
+        );
+        assert_eq!(
+            NaiveDateTime::parse_from_str("1437742189.918273645", "%s%.9f"),
+            Ok(ymdhmsn(2015, 7, 24, 12, 49, 49, 918273645))
+        );
+    }
+
+    #[test]
+    fn test_datetime_format() {
+        let dt = NaiveDate::from_ymd(2010, 9, 8).and_hms_milli(7, 6, 54, 321);
+        assert_eq!(dt.format("%c").to_string(), "Wed Sep  8 07:06:54 2010");
+        assert_eq!(dt.format("%s").to_string(), "1283929614");
+        assert_eq!(dt.format("%t%n%%%n%t").to_string(), "\t\n%\n\t");
+
+        // a horror of leap second: coming near to you.
+        let dt = NaiveDate::from_ymd(2012, 6, 30).and_hms_milli(23, 59, 59, 1_000);
+        assert_eq!(dt.format("%c").to_string(), "Sat Jun 30 23:59:60 2012");
+        assert_eq!(dt.format("%s").to_string(), "1341100799"); // not 1341100800, it's intentional.
+    }
+
+    #[test]
+    fn test_datetime_add_sub_invariant() {
+        // issue #37
+        let base = NaiveDate::from_ymd(2000, 1, 1).and_hms(0, 0, 0);
+        let t = -946684799990000;
+        let time = base + Duration::microseconds(t);
+        assert_eq!(t, time.signed_duration_since(base).num_microseconds().unwrap());
+    }
+
+    #[test]
+    fn test_nanosecond_range() {
+        const A_BILLION: i64 = 1_000_000_000;
+        let maximum = "2262-04-11T23:47:16.854775804";
+        let parsed: NaiveDateTime = maximum.parse().unwrap();
+        let nanos = parsed.timestamp_nanos();
+        assert_eq!(
+            parsed,
+            NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32)
+        );
+
+        let minimum = "1677-09-21T00:12:44.000000000";
+        let parsed: NaiveDateTime = minimum.parse().unwrap();
+        let nanos = parsed.timestamp_nanos();
+        assert_eq!(
+            parsed,
+            NaiveDateTime::from_timestamp(nanos / A_BILLION, (nanos % A_BILLION) as u32)
+        );
+    }
+}
diff --git a/third_party/rust/chrono/src/naive/internals.rs b/third_party/rust/chrono/src/naive/internals.rs
new file mode 100644
index 0000000000..346063c375
--- /dev/null
+++ b/third_party/rust/chrono/src/naive/internals.rs
@@ -0,0 +1,815 @@
+// This is a part of Chrono.
+// See README.md and LICENSE.txt for details.
+
+//! The internal implementation of the calendar and ordinal date.
+//!
+//! The current implementation is optimized for determining year, month, day and day of week.
+//! 4-bit `YearFlags` map to one of 14 possible classes of year in the Gregorian calendar,
+//! which are included in every packed `NaiveDate` instance.
+//! The conversion between the packed calendar date (`Mdf`) and the ordinal date (`Of`) is
+//! based on the moderately-sized lookup table (~1.5KB)
+//! and the packed representation is chosen for the efficient lookup.
+//! Every internal data structure does not validate its input,
+//! but the conversion keeps the valid value valid and the invalid value invalid
+//! so that the user-facing `NaiveDate` can validate the input as late as possible.
+
+#![allow(dead_code)] // some internal methods have been left for consistency
+#![cfg_attr(feature = "__internal_bench", allow(missing_docs))]
+
+use core::{fmt, i32};
+use div::{div_rem, mod_floor};
+use num_traits::FromPrimitive;
+use Weekday;
+
+/// The internal date representation. This also includes the packed `Mdf` value.
+pub type DateImpl = i32;
+
+pub const MAX_YEAR: DateImpl = i32::MAX >> 13;
+pub const MIN_YEAR: DateImpl = i32::MIN >> 13;
+
+/// The year flags (aka the dominical letter).
+///
+/// There are 14 possible classes of year in the Gregorian calendar:
+/// common and leap years starting with Monday through Sunday.
+/// The `YearFlags` stores this information into 4 bits `abbb`,
+/// where `a` is `1` for the common year (simplifies the `Of` validation)
+/// and `bbb` is a non-zero `Weekday` (mapping `Mon` to 7) of the last day in the past year
+/// (simplifies the day of week calculation from the 1-based ordinal).
+#[derive(PartialEq, Eq, Copy, Clone)]
+pub struct YearFlags(pub u8);
+
+pub const A: YearFlags = YearFlags(0o15);
+pub const AG: YearFlags = YearFlags(0o05);
+pub const B: YearFlags = YearFlags(0o14);
+pub const BA: YearFlags = YearFlags(0o04);
+pub const C: YearFlags = YearFlags(0o13);
+pub const CB: YearFlags = YearFlags(0o03);
+pub const D: YearFlags = YearFlags(0o12);
+pub const DC: YearFlags = YearFlags(0o02);
+pub const E: YearFlags = YearFlags(0o11);
+pub const ED: YearFlags = YearFlags(0o01);
+pub const F: YearFlags = YearFlags(0o17);
+pub const FE: YearFlags = YearFlags(0o07);
+pub const G: YearFlags = YearFlags(0o16);
+pub const GF: YearFlags = YearFlags(0o06);
+
+static YEAR_TO_FLAGS: [YearFlags; 400] = [
+    BA, G, F, E, DC, B, A, G, FE, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA,
+    G, F, E, DC, B, A, G, FE, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G,
+    F, E, DC, B, A, G, FE, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F,
+    E, DC, B, A, G, FE, D, C, B, AG, F, E, D, // 100
+    C, B, A, G, FE, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC,
+    B, A, G, FE, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B,
+    A, G, FE, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A,
+    G, FE, D, C, B, AG, F, E, D, CB, A, G, F, // 200
+    E, D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A, G, FE,
+    D, C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A, G, FE, D,
+    C, B, AG, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A, G, FE, D, C,
+    B, AG, F, E, D, CB, A, G, F, ED, C, B, A, // 300
+    G, F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A, G, FE, D, C, B, AG,
+    F, E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A, G, FE, D, C, B, AG, F,
+    E, D, CB, A, G, F, ED, C, B, A, GF, E, D, C, BA, G, F, E, DC, B, A, G, FE, D, C, B, AG, F, E,
+    D, CB, A, G, F, ED, C, B, A, GF, E, D, C, // 400
+];
+
+static YEAR_DELTAS: [u8; 401] = [
+    0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8,
+    8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14,
+    15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20,
+    21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, // 100
+    25, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,
+    30, 31, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 36,
+    36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 39, 40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42,
+    42, 43, 43, 43, 43, 44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47, 48, 48, 48,
+    48, 49, 49, 49, // 200
+    49, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51, 51, 51, 52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54,
+    54, 55, 55, 55, 55, 56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58, 59, 59, 59, 59, 60, 60, 60,
+    60, 61, 61, 61, 61, 62, 62, 62, 62, 63, 63, 63, 63, 64, 64, 64, 64, 65, 65, 65, 65, 66, 66, 66,
+    66, 67, 67, 67, 67, 68, 68, 68, 68, 69, 69, 69, 69, 70, 70, 70, 70, 71, 71, 71, 71, 72, 72, 72,
+    72, 73, 73, 73, // 300
+    73, 73, 73, 73, 73, 74, 74, 74, 74, 75, 75, 75, 75, 76, 76, 76, 76, 77, 77, 77, 77, 78, 78, 78,
+    78, 79, 79, 79, 79, 80, 80, 80, 80, 81, 81, 81, 81, 82, 82, 82, 82, 83, 83, 83, 83, 84, 84, 84,
+    84, 85, 85, 85, 85, 86, 86, 86, 86, 87, 87, 87, 87, 88, 88, 88, 88, 89, 89, 89, 89, 90, 90, 90,
+    90, 91, 91, 91, 91, 92, 92, 92, 92, 93, 93, 93, 93, 94, 94, 94, 94, 95, 95, 95, 95, 96, 96, 96,
+    96, 97, 97, 97, 97, // 400+1
+];
+
+pub fn cycle_to_yo(cycle: u32) -> (u32, u32) {
+    let (mut year_mod_400, mut ordinal0) = div_rem(cycle, 365);
+    let delta = u32::from(YEAR_DELTAS[year_mod_400 as usize]);
+    if ordinal0 < delta {
+        year_mod_400 -= 1;
+        ordinal0 += 365 - u32::from(YEAR_DELTAS[year_mod_400 as usize]);
+    } else {
+        ordinal0 -= delta;
+    }
+    (year_mod_400, ordinal0 + 1)
+}
+
+pub fn yo_to_cycle(year_mod_400: u32, ordinal: u32) -> u32 {
+    year_mod_400 * 365 + u32::from(YEAR_DELTAS[year_mod_400 as usize]) + ordinal - 1
+}
+
+impl YearFlags {
+    #[inline]
+    pub fn from_year(year: i32) -> YearFlags {
+        let year = mod_floor(year, 400);
+        YearFlags::from_year_mod_400(year)
+    }
+
+    #[inline]
+    pub fn from_year_mod_400(year: i32) -> YearFlags {
+        YEAR_TO_FLAGS[year as usize]
+    }
+
+    #[inline]
+    pub fn ndays(&self) -> u32 {
+        let YearFlags(flags) = *self;
+        366 - u32::from(flags >> 3)
+    }
+
+    #[inline]
+    pub fn isoweek_delta(&self) -> u32 {
+        let YearFlags(flags) = *self;
+        let mut delta = u32::from(flags) & 0b0111;
+        if delta < 3 {
+            delta += 7;
+        }
+        delta
+    }
+
+    #[inline]
+    pub fn nisoweeks(&self) -> u32 {
+        let YearFlags(flags) = *self;
+        52 + ((0b0000_0100_0000_0110 >> flags as usize) & 1)
+    }
+}
+
+impl fmt::Debug for YearFlags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let YearFlags(flags) = *self;
+        match flags {
+            0o15 => "A".fmt(f),
+            0o05 => "AG".fmt(f),
+            0o14 => "B".fmt(f),
+            0o04 => "BA".fmt(f),
+            0o13 => "C".fmt(f),
+            0o03 => "CB".fmt(f),
+            0o12 => "D".fmt(f),
+            0o02 => "DC".fmt(f),
+            0o11 => "E".fmt(f),
+            0o01 => "ED".fmt(f),
+            0o10 => "F?".fmt(f),
+            0o00 => "FE?".fmt(f), // non-canonical
+            0o17 => "F".fmt(f),
+            0o07 => "FE".fmt(f),
+            0o16 => "G".fmt(f),
+            0o06 => "GF".fmt(f),
+            _ => write!(f, "YearFlags({})", flags),
+        }
+    }
+}
+
+pub const MIN_OL: u32 = 1 << 1;
+pub const MAX_OL: u32 = 366 << 1; // larger than the non-leap last day `(365 << 1) | 1`
+pub const MIN_MDL: u32 = (1 << 6) | (1 << 1);
+pub const MAX_MDL: u32 = (12 << 6) | (31 << 1) | 1;
+
+const XX: i8 = -128;
+static MDL_TO_OL: [i8; MAX_MDL as usize + 1] = [
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX,
+    XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, XX, // 0
+    XX, XX, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 1
+    XX, XX, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+    66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+    66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, XX, XX, XX, XX, XX, // 2
+    XX, XX, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74,
+    72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74,
+    72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, // 3
+    XX, XX, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76,
+    74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76,
+    74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, XX, XX, // 4
+    XX, XX, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80,
+    78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80,
+    78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, // 5
+    XX, XX, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82,
+    80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82,
+    80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, XX, XX, // 6
+    XX, XX, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86,
+    84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86,
+    84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, // 7
+    XX, XX, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88,
+    86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88,
+    86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, // 8
+    XX, XX, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90,
+    88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90,
+    88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, XX, XX, // 9
+    XX, XX, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94,
+    92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94,
+    92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, // 10
+    XX, XX, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96,
+    94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96,
+    94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, XX, XX, // 11
+    XX, XX, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98,
+    100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100,
+    98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98,
+    100, // 12
+];
+
+static OL_TO_MDL: [u8; MAX_OL as usize + 1] = [
+    0, 0, // 0
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 1
+    66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+    66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
+    66, 66, 66, 66, 66, 66, 66, 66, 66, // 2
+    74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72,
+    74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72,
+    74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, 74, 72, // 3
+    76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74,
+    76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74,
+    76, 74, 76, 74, 76, 74, 76, 74, 76, 74, 76, 74, // 4
+    80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78,
+    80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78,
+    80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, 80, 78, // 5
+    82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80,
+    82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80,
+    82, 80, 82, 80, 82, 80, 82, 80, 82, 80, 82, 80, // 6
+    86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84,
+    86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84,
+    86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, 86, 84, // 7
+    88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86,
+    88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86,
+    88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, 88, 86, // 8
+    90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88,
+    90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88,
+    90, 88, 90, 88, 90, 88, 90, 88, 90, 88, 90, 88, // 9
+    94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92,
+    94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92,
+    94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, 94, 92, // 10
+    96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94,
+    96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94,
+    96, 94, 96, 94, 96, 94, 96, 94, 96, 94, 96, 94, // 11
+    100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100,
+    98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98,
+    100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100, 98, 100,
+    98, // 12
+];
+
+/// Ordinal (day of year) and year flags: `(ordinal << 4) | flags`.
+///
+/// The whole bits except for the least 3 bits are referred as `Ol` (ordinal and leap flag),
+/// which is an index to the `OL_TO_MDL` lookup table.
+#[derive(PartialEq, PartialOrd, Copy, Clone)]
+pub struct Of(pub u32);
+
+impl Of {
+    #[inline]
+    fn clamp_ordinal(ordinal: u32) -> u32 {
+        if ordinal > 366 {
+            0
+        } else {
+            ordinal
+        }
+    }
+
+    #[inline]
+    pub fn new(ordinal: u32, YearFlags(flags): YearFlags) -> Of {
+        let ordinal = Of::clamp_ordinal(ordinal);
+        Of((ordinal << 4) | u32::from(flags))
+    }
+
+    #[inline]
+    pub fn from_mdf(Mdf(mdf): Mdf) -> Of {
+        let mdl = mdf >> 3;
+        match MDL_TO_OL.get(mdl as usize) {
+            Some(&v) => Of(mdf.wrapping_sub((i32::from(v) as u32 & 0x3ff) << 3)),
+            None => Of(0),
+        }
+    }
+
+    #[inline]
+    pub fn valid(&self) -> bool {
+        let Of(of) = *self;
+        let ol = of >> 3;
+        MIN_OL <= ol && ol <= MAX_OL
+    }
+
+    #[inline]
+    pub fn ordinal(&self) -> u32 {
+        let Of(of) = *self;
+        of >> 4
+    }
+
+    #[inline]
+    pub fn with_ordinal(&self, ordinal: u32) -> Of {
+        let ordinal = Of::clamp_ordinal(ordinal);
+        let Of(of) = *self;
+        Of((of & 0b1111) | (ordinal << 4))
+    }
+
+    #[inline]
+    pub fn flags(&self) -> YearFlags {
+        let Of(of) = *self;
+        YearFlags((of & 0b1111) as u8)
+    }
+
+    #[inline]
+    pub fn with_flags(&self, YearFlags(flags): YearFlags) -> Of {
+        let Of(of) = *self;
+        Of((of & !0b1111) | u32::from(flags))
+    }
+
+    #[inline]
+    pub fn weekday(&self) -> Weekday {
+        let Of(of) = *self;
+        Weekday::from_u32(((of >> 4) + (of & 0b111)) % 7).unwrap()
+    }
+
+    #[inline]
+    pub fn isoweekdate_raw(&self) -> (u32, Weekday) {
+        // week ordinal = ordinal + delta
+        let Of(of) = *self;
+        let weekord = (of >> 4).wrapping_add(self.flags().isoweek_delta());
+        (weekord / 7, Weekday::from_u32(weekord % 7).unwrap())
+    }
+
+    #[inline]
+    pub fn to_mdf(&self) -> Mdf {
+        Mdf::from_of(*self)
+    }
+
+    #[inline]
+    pub fn succ(&self) -> Of {
+        let Of(of) = *self;
+        Of(of + (1 << 4))
+    }
+
+    #[inline]
+    pub fn pred(&self) -> Of {
+        let Of(of) = *self;
+        Of(of - (1 << 4))
+    }
+}
+
+impl fmt::Debug for Of {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let Of(of) = *self;
+        write!(
+            f,
+            "Of(({} << 4) | {:#04o} /*{:?}*/)",
+            of >> 4,
+            of & 0b1111,
+            YearFlags((of & 0b1111) as u8)
+        )
+    }
+}
+
+/// Month, day of month and year flags: `(month << 9) | (day << 4) | flags`
+///
+/// The whole bits except for the least 3 bits are referred as `Mdl`
+/// (month, day of month and leap flag),
+/// which is an index to the `MDL_TO_OL` lookup table.
+#[derive(PartialEq, PartialOrd, Copy, Clone)]
+pub struct Mdf(pub u32);
+
+impl Mdf {
+    #[inline]
+    fn clamp_month(month: u32) -> u32 {
+        if month > 12 {
+            0
+        } else {
+            month
+        }
+    }
+
+    #[inline]
+    fn clamp_day(day: u32) -> u32 {
+        if day > 31 {
+            0
+        } else {
+            day
+        }
+    }
+
+    #[inline]
+    pub fn new(month: u32, day: u32, YearFlags(flags): YearFlags) -> Mdf {
+        let month = Mdf::clamp_month(month);
+        let day = Mdf::clamp_day(day);
+        Mdf((month << 9) | (day << 4) | u32::from(flags))
+    }
+
+    #[inline]
+    pub fn from_of(Of(of): Of) -> Mdf {
+        let ol = of >> 3;
+        match OL_TO_MDL.get(ol as usize) {
+            Some(&v) => Mdf(of + (u32::from(v) << 3)),
+            None => Mdf(0),
+        }
+    }
+
+    #[inline]
+    pub fn valid(&self) -> bool {
+        let Mdf(mdf) = *self;
+        let mdl = mdf >> 3;
+        match MDL_TO_OL.get(mdl as usize) {
+            Some(&v) => v >= 0,
+            None => false,
+        }
+    }
+
+    #[inline]
+    pub fn month(&self) -> u32 {
+        let Mdf(mdf) = *self;
+        mdf >> 9
+    }
+
+    #[inline]
+    pub fn with_month(&self, month: u32) -> Mdf {
+        let month = Mdf::clamp_month(month);
+        let Mdf(mdf) = *self;
+        Mdf((mdf & 0b1_1111_1111) | (month << 9))
+    }
+
+    #[inline]
+    pub fn day(&self) -> u32 {
+        let Mdf(mdf) = *self;
+        (mdf >> 4) & 0b1_1111
+    }
+
+    #[inline]
+    pub fn with_day(&self, day: u32) -> Mdf {
+        let day = Mdf::clamp_day(day);
+        let Mdf(mdf) = *self;
+        Mdf((mdf & !0b1_1111_0000) | (day << 4))
+    }
+
+    #[inline]
+    pub fn flags(&self) -> YearFlags {
+        let Mdf(mdf) = *self;
+        YearFlags((mdf & 0b1111) as u8)
+    }
+
+    #[inline]
+    pub fn with_flags(&self, YearFlags(flags): YearFlags) -> Mdf {
+        let Mdf(mdf) = *self;
+        Mdf((mdf & !0b1111) | u32::from(flags))
+    }
+
+    #[inline]
+    pub fn to_of(&self) -> Of {
+        Of::from_mdf(*self)
+    }
+}
+
+impl fmt::Debug for Mdf {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let Mdf(mdf) = *self;
+        write!(
+            f,
+            "Mdf(({} << 9) | ({} << 4) | {:#04o} /*{:?}*/)",
+            mdf >> 9,
+            (mdf >> 4) & 0b1_1111,
+            mdf & 0b1111,
+            YearFlags((mdf & 0b1111) as u8)
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(test)]
+    extern crate num_iter;
+
+    use self::num_iter::range_inclusive;
+    use super::{Mdf, Of};
+    use super::{YearFlags, A, AG, B, BA, C, CB, D, DC, E, ED, F, FE, G, GF};
+    use std::u32;
+    use Weekday;
+
+    const NONLEAP_FLAGS: [YearFlags; 7] = [A, B, C, D, E, F, G];
+    const LEAP_FLAGS: [YearFlags; 7] = [AG, BA, CB, DC, ED, FE, GF];
+    const FLAGS: [YearFlags; 14] = [A, B, C, D, E, F, G, AG, BA, CB, DC, ED, FE, GF];
+
+    #[test]
+    fn test_year_flags_ndays_from_year() {
+        assert_eq!(YearFlags::from_year(2014).ndays(), 365);
+        assert_eq!(YearFlags::from_year(2012).ndays(), 366);
+        assert_eq!(YearFlags::from_year(2000).ndays(), 366);
+        assert_eq!(YearFlags::from_year(1900).ndays(), 365);
+        assert_eq!(YearFlags::from_year(1600).ndays(), 366);
+        assert_eq!(YearFlags::from_year(1).ndays(), 365);
+        assert_eq!(YearFlags::from_year(0).ndays(), 366); // 1 BCE (proleptic Gregorian)
+        assert_eq!(YearFlags::from_year(-1).ndays(), 365); // 2 BCE
+        assert_eq!(YearFlags::from_year(-4).ndays(), 366); // 5 BCE
+        assert_eq!(YearFlags::from_year(-99).ndays(), 365); // 100 BCE
+        assert_eq!(YearFlags::from_year(-100).ndays(), 365); // 101 BCE
+        assert_eq!(YearFlags::from_year(-399).ndays(), 365); // 400 BCE
+        assert_eq!(YearFlags::from_year(-400).ndays(), 366); // 401 BCE
+    }
+
+    #[test]
+    fn test_year_flags_nisoweeks() {
+        assert_eq!(A.nisoweeks(), 52);
+        assert_eq!(B.nisoweeks(), 52);
+        assert_eq!(C.nisoweeks(), 52);
+        assert_eq!(D.nisoweeks(), 53);
+        assert_eq!(E.nisoweeks(), 52);
+        assert_eq!(F.nisoweeks(), 52);
+        assert_eq!(G.nisoweeks(), 52);
+        assert_eq!(AG.nisoweeks(), 52);
+        assert_eq!(BA.nisoweeks(), 52);
+        assert_eq!(CB.nisoweeks(), 52);
+        assert_eq!(DC.nisoweeks(), 53);
+        assert_eq!(ED.nisoweeks(), 53);
+        assert_eq!(FE.nisoweeks(), 52);
+        assert_eq!(GF.nisoweeks(), 52);
+    }
+
+    #[test]
+    fn test_of() {
+        fn check(expected: bool, flags: YearFlags, ordinal1: u32, ordinal2: u32) {
+            for ordinal in range_inclusive(ordinal1, ordinal2) {
+                let of = Of::new(ordinal, flags);
+                assert!(
+                    of.valid() == expected,
+                    "ordinal {} = {:?} should be {} for dominical year {:?}",
+                    ordinal,
+                    of,
+                    if expected { "valid" } else { "invalid" },
+                    flags
+                );
+            }
+        }
+
+        for &flags in NONLEAP_FLAGS.iter() {
+            check(false, flags, 0, 0);
+            check(true, flags, 1, 365);
+            check(false, flags, 366, 1024);
+            check(false, flags, u32::MAX, u32::MAX);
+        }
+
+        for &flags in LEAP_FLAGS.iter() {
+            check(false, flags, 0, 0);
+            check(true, flags, 1, 366);
+            check(false, flags, 367, 1024);
+            check(false, flags, u32::MAX, u32::MAX);
+        }
+    }
+
+    #[test]
+    fn test_mdf_valid() {
+        fn check(expected: bool, flags: YearFlags, month1: u32, day1: u32, month2: u32, day2: u32) {
+            for month in range_inclusive(month1, month2) {
+                for day in range_inclusive(day1, day2) {
+                    let mdf = Mdf::new(month, day, flags);
+                    assert!(
+                        mdf.valid() == expected,
+                        "month {} day {} = {:?} should be {} for dominical year {:?}",
+                        month,
+                        day,
+                        mdf,
+                        if expected { "valid" } else { "invalid" },
+                        flags
+                    );
+                }
+            }
+        }
+
+        for &flags in NONLEAP_FLAGS.iter() {
+            check(false, flags, 0, 0, 0, 1024);
+            check(false, flags, 0, 0, 16, 0);
+            check(true, flags, 1, 1, 1, 31);
+            check(false, flags, 1, 32, 1, 1024);
+            check(true, flags, 2, 1, 2, 28);
+            check(false, flags, 2, 29, 2, 1024);
+            check(true, flags, 3, 1, 3, 31);
+            check(false, flags, 3, 32, 3, 1024);
+            check(true, flags, 4, 1, 4, 30);
+            check(false, flags, 4, 31, 4, 1024);
+            check(true, flags, 5, 1, 5, 31);
+            check(false, flags, 5, 32, 5, 1024);
+            check(true, flags, 6, 1, 6, 30);
+            check(false, flags, 6, 31, 6, 1024);
+            check(true, flags, 7, 1, 7, 31);
+            check(false, flags, 7, 32, 7, 1024);
+            check(true, flags, 8, 1, 8, 31);
+            check(false, flags, 8, 32, 8, 1024);
+            check(true, flags, 9, 1, 9, 30);
+            check(false, flags, 9, 31, 9, 1024);
+            check(true, flags, 10, 1, 10, 31);
+            check(false, flags, 10, 32, 10, 1024);
+            check(true, flags, 11, 1, 11, 30);
+            check(false, flags, 11, 31, 11, 1024);
+            check(true, flags, 12, 1, 12, 31);
+            check(false, flags, 12, 32, 12, 1024);
+            check(false, flags, 13, 0, 16, 1024);
+            check(false, flags, u32::MAX, 0, u32::MAX, 1024);
+            check(false, flags, 0, u32::MAX, 16, u32::MAX);
+            check(false, flags, u32::MAX, u32::MAX, u32::MAX, u32::MAX);
+        }
+
+        for &flags in LEAP_FLAGS.iter() {
+            check(false, flags, 0, 0, 0, 1024);
+            check(false, flags, 0, 0, 16, 0);
+            check(true, flags, 1, 1, 1, 31);
+            check(false, flags, 1, 32, 1, 1024);
+            check(true, flags, 2, 1, 2, 29);
+            check(false, flags, 2, 30, 2, 1024);
+            check(true, flags, 3, 1, 3, 31);
+            check(false, flags, 3, 32, 3, 1024);
+            check(true, flags, 4, 1, 4, 30);
+            check(false, flags, 4, 31, 4, 1024);
+            check(true, flags, 5, 1, 5, 31);
+            check(false, flags, 5, 32, 5, 1024);
+            check(true, flags, 6, 1, 6, 30);
+            check(false, flags, 6, 31, 6, 1024);
+            check(true, flags, 7, 1, 7, 31);
+            check(false, flags, 7, 32, 7, 1024);
+            check(true, flags, 8, 1, 8, 31);
+            check(false, flags, 8, 32, 8, 1024);
+            check(true, flags, 9, 1, 9, 30);
+            check(false, flags, 9, 31, 9, 1024);
+            check(true, flags, 10, 1, 10, 31);
+            check(false, flags, 10, 32, 10, 1024);
+            check(true, flags, 11, 1, 11, 30);
+            check(false, flags, 11, 31, 11, 1024);
+            check(true, flags, 12, 1, 12, 31);
+            check(false, flags, 12, 32, 12, 1024);
+            check(false, flags, 13, 0, 16, 1024);
+            check(false, flags, u32::MAX, 0, u32::MAX, 1024);
+            check(false, flags, 0, u32::MAX, 16, u32::MAX);
+            check(false, flags, u32::MAX, u32::MAX, u32::MAX, u32::MAX);
+        }
+    }
+
+    #[test]
+    fn test_of_fields() {
+        for &flags in FLAGS.iter() {
+            for ordinal in range_inclusive(1u32, 366) {
+                let of = Of::new(ordinal, flags);
+                if of.valid() {
+                    assert_eq!(of.ordinal(), ordinal);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_of_with_fields() {
+        fn check(flags: YearFlags, ordinal: u32) {
+            let of = Of::new(ordinal, flags);
+
+            for ordinal in range_inclusive(0u32, 1024) {
+                let of = of.with_ordinal(ordinal);
+                assert_eq!(of.valid(), Of::new(ordinal, flags).valid());
+                if of.valid() {
+                    assert_eq!(of.ordinal(), ordinal);
+                }
+            }
+        }
+
+        for &flags in NONLEAP_FLAGS.iter() {
+            check(flags, 1);
+            check(flags, 365);
+        }
+        for &flags in LEAP_FLAGS.iter() {
+            check(flags, 1);
+            check(flags, 366);
+        }
+    }
+
+    #[test]
+    fn test_of_weekday() {
+        assert_eq!(Of::new(1, A).weekday(), Weekday::Sun);
+        assert_eq!(Of::new(1, B).weekday(), Weekday::Sat);
+        assert_eq!(Of::new(1, C).weekday(), Weekday::Fri);
+        assert_eq!(Of::new(1, D).weekday(), Weekday::Thu);
+        assert_eq!(Of::new(1, E).weekday(), Weekday::Wed);
+        assert_eq!(Of::new(1, F).weekday(), Weekday::Tue);
+        assert_eq!(Of::new(1, G).weekday(), Weekday::Mon);
+        assert_eq!(Of::new(1, AG).weekday(), Weekday::Sun);
+        assert_eq!(Of::new(1, BA).weekday(), Weekday::Sat);
+        assert_eq!(Of::new(1, CB).weekday(), Weekday::Fri);
+        assert_eq!(Of::new(1, DC).weekday(), Weekday::Thu);
+        assert_eq!(Of::new(1, ED).weekday(), Weekday::Wed);
+        assert_eq!(Of::new(1, FE).weekday(), Weekday::Tue);
+        assert_eq!(Of::new(1, GF).weekday(), Weekday::Mon);
+
+        for &flags in FLAGS.iter() {
+            let mut prev = Of::new(1, flags).weekday();
+            for ordinal in range_inclusive(2u32, flags.ndays()) {
+                let of = Of::new(ordinal, flags);
+                let expected = prev.succ();
+                assert_eq!(of.weekday(), expected);
+                prev = expected;
+            }
+        }
+    }
+
+    #[test]
+    fn test_mdf_fields() {
+        for &flags in FLAGS.iter() {
+            for month in range_inclusive(1u32, 12) {
+                for day in range_inclusive(1u32, 31) {
+                    let mdf = Mdf::new(month, day, flags);
+                    if mdf.valid() {
+                        assert_eq!(mdf.month(), month);
+                        assert_eq!(mdf.day(), day);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_mdf_with_fields() {
+        fn check(flags: YearFlags, month: u32, day: u32) {
+            let mdf = Mdf::new(month, day, flags);
+
+            for month in range_inclusive(0u32, 16) {
+                let mdf = mdf.with_month(month);
+                assert_eq!(mdf.valid(), Mdf::new(month, day, flags).valid());
+                if mdf.valid() {
+                    assert_eq!(mdf.month(), month);
+                    assert_eq!(mdf.day(), day);
+                }
+            }
+
+            for day in range_inclusive(0u32, 1024) {
+                let mdf = mdf.with_day(day);
+                assert_eq!(mdf.valid(), Mdf::new(month, day, flags).valid());
+                if mdf.valid() {
+                    assert_eq!(mdf.month(), month);
+                    assert_eq!(mdf.day(), day);
+                }
+            }
+        }
+
+        for &flags in NONLEAP_FLAGS.iter() {
+            check(flags, 1, 1);
+            check(flags, 1, 31);
+            check(flags, 2, 1);
+            check(flags, 2, 28);
+            check(flags, 2, 29);
+            check(flags, 12, 31);
+        }
+        for &flags in LEAP_FLAGS.iter() {
+            check(flags, 1, 1);
+            check(flags, 1, 31);
+            check(flags, 2, 1);
+            check(flags, 2, 29);
+            check(flags, 2, 30);
+            check(flags, 12, 31);
+        }
+    }
+
+    #[test]
+    fn test_of_isoweekdate_raw() {
+        for &flags in FLAGS.iter() {
+            // January 4 should be in the first week
+            let (week, _) = Of::new(4 /* January 4 */, flags).isoweekdate_raw();
+            assert_eq!(week, 1);
+        }
+    }
+
+    #[test]
+    fn test_of_to_mdf() {
+        for i in range_inclusive(0u32, 8192) {
+            let of = Of(i);
+            assert_eq!(of.valid(), of.to_mdf().valid());
+        }
+    }
+
+    #[test]
+    fn test_mdf_to_of() {
+        for i in range_inclusive(0u32, 8192) {
+            let mdf = Mdf(i);
+            assert_eq!(mdf.valid(), mdf.to_of().valid());
+        }
+    }
+
+    #[test]
+    fn test_of_to_mdf_to_of() {
+        for i in range_inclusive(0u32, 8192) {
+            let of = Of(i);
+            if of.valid() {
+                assert_eq!(of, of.to_mdf().to_of());
+            }
+        }
+    }
+
+    #[test]
+    fn test_mdf_to_of_to_mdf() {
+        for i in range_inclusive(0u32, 8192) {
+            let mdf = Mdf(i);
+            if mdf.valid() {
+                assert_eq!(mdf, mdf.to_of().to_mdf());
+            }
+        }
+    }
+}
diff --git a/third_party/rust/chrono/src/naive/isoweek.rs b/third_party/rust/chrono/src/naive/isoweek.rs
new file mode 100644
index 0000000000..ece10f250b
--- /dev/null
+++ b/third_party/rust/chrono/src/naive/isoweek.rs
@@ -0,0 +1,163 @@
+// This is a part of Chrono.
+// See README.md and LICENSE.txt for details.
+
+//! ISO 8601 week.
+
+use core::fmt;
+
+use super::internals::{DateImpl, Of, YearFlags};
+
+/// ISO 8601 week.
+///
+/// This type, combined with [`Weekday`](../enum.Weekday.html),
+/// constitues the ISO 8601 [week date](./struct.NaiveDate.html#week-date).
+/// One can retrieve this type from the existing [`Datelike`](../trait.Datelike.html) types
+/// via the [`Datelike::iso_week`](../trait.Datelike.html#tymethod.iso_week) method.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
+pub struct IsoWeek {
+    // note that this allows for larger year range than `NaiveDate`.
+    // this is crucial because we have an edge case for the first and last week supported,
+    // which year number might not match the calendar year number.
+    ywf: DateImpl, // (year << 10) | (week << 4) | flag
+}
+
+/// Returns the corresponding `IsoWeek` from the year and the `Of` internal value.
+//
+// internal use only. we don't expose the public constructor for `IsoWeek` for now,
+// because the year range for the week date and the calendar date do not match and
+// it is confusing to have a date that is out of range in one and not in another.
+// currently we sidestep this issue by making `IsoWeek` fully dependent of `Datelike`.
+pub fn iso_week_from_yof(year: i32, of: Of) -> IsoWeek {
+    let (rawweek, _) = of.isoweekdate_raw();
+    let (year, week) = if rawweek < 1 {
+        // previous year
+        let prevlastweek = YearFlags::from_year(year - 1).nisoweeks();
+        (year - 1, prevlastweek)
+    } else {
+        let lastweek = of.flags().nisoweeks();
+        if rawweek > lastweek {
+            // next year
+            (year + 1, 1)
+        } else {
+            (year, rawweek)
+        }
+    };
+    IsoWeek { ywf: (year << 10) | (week << 4) as DateImpl | DateImpl::from(of.flags().0) }
+}
+
+impl IsoWeek {
+    /// Returns the year number for this ISO week.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_isoywd(2015, 1, Weekday::Mon);
+    /// assert_eq!(d.iso_week().year(), 2015);
+    /// ~~~~
+    ///
+    /// This year number might not match the calendar year number.
+    /// Continuing the example...
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveDate, Datelike, Weekday};
+    /// # let d = NaiveDate::from_isoywd(2015, 1, Weekday::Mon);
+    /// assert_eq!(d.year(), 2014);
+    /// assert_eq!(d, NaiveDate::from_ymd(2014, 12, 29));
+    /// ~~~~
+    #[inline]
+    pub fn year(&self) -> i32 {
+        self.ywf >> 10
+    }
+
+    /// Returns the ISO week number starting from 1.
+    ///
+    /// The return value ranges from 1 to 53. (The last week of year differs by years.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_isoywd(2015, 15, Weekday::Mon);
+    /// assert_eq!(d.iso_week().week(), 15);
+    /// ~~~~
+    #[inline]
+    pub fn week(&self) -> u32 {
+        ((self.ywf >> 4) & 0x3f) as u32
+    }
+
+    /// Returns the ISO week number starting from 0.
+    ///
+    /// The return value ranges from 0 to 52. (The last week of year differs by years.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveDate, Datelike, Weekday};
+    ///
+    /// let d = NaiveDate::from_isoywd(2015, 15, Weekday::Mon);
+    /// assert_eq!(d.iso_week().week0(), 14);
+    /// ~~~~
+    #[inline]
+    pub fn week0(&self) -> u32 {
+        ((self.ywf >> 4) & 0x3f) as u32 - 1
+    }
+}
+
+/// The `Debug` output of the ISO week `w` is the same as
+/// [`d.format("%G-W%V")`](../format/strftime/index.html)
+/// where `d` is any `NaiveDate` value in that week.
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::{NaiveDate, Datelike};
+///
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(2015,  9,  5).iso_week()), "2015-W36");
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(   0,  1,  3).iso_week()), "0000-W01");
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(9999, 12, 31).iso_week()), "9999-W52");
+/// ~~~~
+///
+/// ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.
+///
+/// ~~~~
+/// # use chrono::{NaiveDate, Datelike};
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(    0,  1,  2).iso_week()),  "-0001-W52");
+/// assert_eq!(format!("{:?}", NaiveDate::from_ymd(10000, 12, 31).iso_week()), "+10000-W52");
+/// ~~~~
+impl fmt::Debug for IsoWeek {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let year = self.year();
+        let week = self.week();
+        if 0 <= year && year <= 9999 {
+            write!(f, "{:04}-W{:02}", year, week)
+        } else {
+            // ISO 8601 requires the explicit sign for out-of-range years
+            write!(f, "{:+05}-W{:02}", year, week)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use naive::{internals, MAX_DATE, MIN_DATE};
+    use Datelike;
+
+    #[test]
+    fn test_iso_week_extremes() {
+        let minweek = MIN_DATE.iso_week();
+        let maxweek = MAX_DATE.iso_week();
+
+        assert_eq!(minweek.year(), internals::MIN_YEAR);
+        assert_eq!(minweek.week(), 1);
+        assert_eq!(minweek.week0(), 0);
+        assert_eq!(format!("{:?}", minweek), MIN_DATE.format("%G-W%V").to_string());
+
+        assert_eq!(maxweek.year(), internals::MAX_YEAR + 1);
+        assert_eq!(maxweek.week(), 1);
+        assert_eq!(maxweek.week0(), 0);
+        assert_eq!(format!("{:?}", maxweek), MAX_DATE.format("%G-W%V").to_string());
+    }
+}
diff --git a/third_party/rust/chrono/src/naive/time.rs b/third_party/rust/chrono/src/naive/time.rs
new file mode 100644
index 0000000000..1ddc9fbedc
--- /dev/null
+++ b/third_party/rust/chrono/src/naive/time.rs
@@ -0,0 +1,1814 @@
+// This is a part of Chrono.
+// See README.md and LICENSE.txt for details.
+
+//! ISO 8601 time without timezone.
+
+#[cfg(any(feature = "alloc", feature = "std", test))]
+use core::borrow::Borrow;
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+use core::{fmt, hash, str};
+use oldtime::Duration as OldDuration;
+
+use div::div_mod_floor;
+#[cfg(any(feature = "alloc", feature = "std", test))]
+use format::DelayedFormat;
+use format::{parse, ParseError, ParseResult, Parsed, StrftimeItems};
+use format::{Fixed, Item, Numeric, Pad};
+use Timelike;
+
+pub const MIN_TIME: NaiveTime = NaiveTime { secs: 0, frac: 0 };
+pub const MAX_TIME: NaiveTime = NaiveTime { secs: 23 * 3600 + 59 * 60 + 59, frac: 999_999_999 };
+
+/// ISO 8601 time without timezone.
+/// Allows for the nanosecond precision and optional leap second representation.
+///
+/// # Leap Second Handling
+///
+/// Since 1960s, the manmade atomic clock has been so accurate that
+/// it is much more accurate than Earth's own motion.
+/// It became desirable to define the civil time in terms of the atomic clock,
+/// but that risks the desynchronization of the civil time from Earth.
+/// To account for this, the designers of the Coordinated Universal Time (UTC)
+/// made that the UTC should be kept within 0.9 seconds of the observed Earth-bound time.
+/// When the mean solar day is longer than the ideal (86,400 seconds),
+/// the error slowly accumulates and it is necessary to add a **leap second**
+/// to slow the UTC down a bit.
+/// (We may also remove a second to speed the UTC up a bit, but it never happened.)
+/// The leap second, if any, follows 23:59:59 of June 30 or December 31 in the UTC.
+///
+/// Fast forward to the 21st century,
+/// we have seen 26 leap seconds from January 1972 to December 2015.
+/// Yes, 26 seconds. Probably you can read this paragraph within 26 seconds.
+/// But those 26 seconds, and possibly more in the future, are never predictable,
+/// and whether to add a leap second or not is known only before 6 months.
+/// Internet-based clocks (via NTP) do account for known leap seconds,
+/// but the system API normally doesn't (and often can't, with no network connection)
+/// and there is no reliable way to retrieve leap second information.
+///
+/// Chrono does not try to accurately implement leap seconds; it is impossible.
+/// Rather, **it allows for leap seconds but behaves as if there are *no other* leap seconds.**
+/// Various operations will ignore any possible leap second(s)
+/// except when any of the operands were actually leap seconds.
+///
+/// If you cannot tolerate this behavior,
+/// you must use a separate `TimeZone` for the International Atomic Time (TAI).
+/// TAI is like UTC but has no leap seconds, and thus slightly differs from UTC.
+/// Chrono does not yet provide such implementation, but it is planned.
+///
+/// ## Representing Leap Seconds
+///
+/// The leap second is indicated via fractional seconds more than 1 second.
+/// This makes possible to treat a leap second as the prior non-leap second
+/// if you don't care about sub-second accuracy.
+/// You should use the proper formatting to get the raw leap second.
+///
+/// All methods accepting fractional seconds will accept such values.
+///
+/// ~~~~
+/// use chrono::{NaiveDate, NaiveTime, Utc, TimeZone};
+///
+/// let t = NaiveTime::from_hms_milli(8, 59, 59, 1_000);
+///
+/// let dt1 = NaiveDate::from_ymd(2015, 7, 1).and_hms_micro(8, 59, 59, 1_000_000);
+///
+/// let dt2 = Utc.ymd(2015, 6, 30).and_hms_nano(23, 59, 59, 1_000_000_000);
+/// # let _ = (t, dt1, dt2);
+/// ~~~~
+///
+/// Note that the leap second can happen anytime given an appropriate time zone;
+/// 2015-07-01 01:23:60 would be a proper leap second if UTC+01:24 had existed.
+/// Practically speaking, though, by the time of the first leap second on 1972-06-30,
+/// every time zone offset around the world has standardized to the 5-minute alignment.
+///
+/// ## Date And Time Arithmetics
+///
+/// As a concrete example, let's assume that `03:00:60` and `04:00:60` are leap seconds.
+/// In reality, of course, leap seconds are separated by at least 6 months.
+/// We will also use some intuitive concise notations for the explanation.
+///
+/// `Time + Duration`
+/// (short for [`NaiveTime::overflowing_add_signed`](#method.overflowing_add_signed)):
+///
+/// - `03:00:00 + 1s = 03:00:01`.
+/// - `03:00:59 + 60s = 03:02:00`.
+/// - `03:00:59 + 1s = 03:01:00`.
+/// - `03:00:60 + 1s = 03:01:00`.
+///   Note that the sum is identical to the previous.
+/// - `03:00:60 + 60s = 03:01:59`.
+/// - `03:00:60 + 61s = 03:02:00`.
+/// - `03:00:60.1 + 0.8s = 03:00:60.9`.
+///
+/// `Time - Duration`
+/// (short for [`NaiveTime::overflowing_sub_signed`](#method.overflowing_sub_signed)):
+///
+/// - `03:00:00 - 1s = 02:59:59`.
+/// - `03:01:00 - 1s = 03:00:59`.
+/// - `03:01:00 - 60s = 03:00:00`.
+/// - `03:00:60 - 60s = 03:00:00`.
+///   Note that the result is identical to the previous.
+/// - `03:00:60.7 - 0.4s = 03:00:60.3`.
+/// - `03:00:60.7 - 0.9s = 03:00:59.8`.
+///
+/// `Time - Time`
+/// (short for [`NaiveTime::signed_duration_since`](#method.signed_duration_since)):
+///
+/// - `04:00:00 - 03:00:00 = 3600s`.
+/// - `03:01:00 - 03:00:00 = 60s`.
+/// - `03:00:60 - 03:00:00 = 60s`.
+///   Note that the difference is identical to the previous.
+/// - `03:00:60.6 - 03:00:59.4 = 1.2s`.
+/// - `03:01:00 - 03:00:59.8 = 0.2s`.
+/// - `03:01:00 - 03:00:60.5 = 0.5s`.
+///   Note that the difference is larger than the previous,
+///   even though the leap second clearly follows the previous whole second.
+/// - `04:00:60.9 - 03:00:60.1 =
+///   (04:00:60.9 - 04:00:00) + (04:00:00 - 03:01:00) + (03:01:00 - 03:00:60.1) =
+///   60.9s + 3540s + 0.9s = 3601.8s`.
+///
+/// In general,
+///
+/// - `Time + Duration` unconditionally equals to `Duration + Time`.
+///
+/// - `Time - Duration` unconditionally equals to `Time + (-Duration)`.
+///
+/// - `Time1 - Time2` unconditionally equals to `-(Time2 - Time1)`.
+///
+/// - Associativity does not generally hold, because
+///   `(Time + Duration1) - Duration2` no longer equals to `Time + (Duration1 - Duration2)`
+///   for two positive durations.
+///
+///     - As a special case, `(Time + Duration) - Duration` also does not equal to `Time`.
+///
+///     - If you can assume that all durations have the same sign, however,
+///       then the associativity holds:
+///       `(Time + Duration1) + Duration2` equals to `Time + (Duration1 + Duration2)`
+///       for two positive durations.
+///
+/// ## Reading And Writing Leap Seconds
+///
+/// The "typical" leap seconds on the minute boundary are
+/// correctly handled both in the formatting and parsing.
+/// The leap second in the human-readable representation
+/// will be represented as the second part being 60, as required by ISO 8601.
+///
+/// ~~~~
+/// use chrono::{Utc, TimeZone};
+///
+/// let dt = Utc.ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_000);
+/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:59:60Z");
+/// ~~~~
+///
+/// There are hypothetical leap seconds not on the minute boundary
+/// nevertheless supported by Chrono.
+/// They are allowed for the sake of completeness and consistency;
+/// there were several "exotic" time zone offsets with fractional minutes prior to UTC after all.
+/// For such cases the human-readable representation is ambiguous
+/// and would be read back to the next non-leap second.
+///
+/// ~~~~
+/// use chrono::{DateTime, Utc, TimeZone};
+///
+/// let dt = Utc.ymd(2015, 6, 30).and_hms_milli(23, 56, 4, 1_000);
+/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z");
+///
+/// let dt = Utc.ymd(2015, 6, 30).and_hms(23, 56, 5);
+/// assert_eq!(format!("{:?}", dt), "2015-06-30T23:56:05Z");
+/// assert_eq!(DateTime::parse_from_rfc3339("2015-06-30T23:56:05Z").unwrap(), dt);
+/// ~~~~
+///
+/// Since Chrono alone cannot determine any existence of leap seconds,
+/// **there is absolutely no guarantee that the leap second read has actually happened**.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone)]
+pub struct NaiveTime {
+    secs: u32,
+    frac: u32,
+}
+
+impl NaiveTime {
+    /// Makes a new `NaiveTime` from hour, minute and second.
+    ///
+    /// No [leap second](#leap-second-handling) is allowed here;
+    /// use `NaiveTime::from_hms_*` methods with a subsecond parameter instead.
+    ///
+    /// Panics on invalid hour, minute and/or second.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let t = NaiveTime::from_hms(23, 56, 4);
+    /// assert_eq!(t.hour(), 23);
+    /// assert_eq!(t.minute(), 56);
+    /// assert_eq!(t.second(), 4);
+    /// assert_eq!(t.nanosecond(), 0);
+    /// ~~~~
+    #[inline]
+    pub fn from_hms(hour: u32, min: u32, sec: u32) -> NaiveTime {
+        NaiveTime::from_hms_opt(hour, min, sec).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute and second.
+    ///
+    /// No [leap second](#leap-second-handling) is allowed here;
+    /// use `NaiveTime::from_hms_*_opt` methods with a subsecond parameter instead.
+    ///
+    /// Returns `None` on invalid hour, minute and/or second.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let from_hms_opt = NaiveTime::from_hms_opt;
+    ///
+    /// assert!(from_hms_opt(0, 0, 0).is_some());
+    /// assert!(from_hms_opt(23, 59, 59).is_some());
+    /// assert!(from_hms_opt(24, 0, 0).is_none());
+    /// assert!(from_hms_opt(23, 60, 0).is_none());
+    /// assert!(from_hms_opt(23, 59, 60).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_opt(hour: u32, min: u32, sec: u32) -> Option<NaiveTime> {
+        NaiveTime::from_hms_nano_opt(hour, min, sec, 0)
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute, second and millisecond.
+    ///
+    /// The millisecond part can exceed 1,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Panics on invalid hour, minute, second and/or millisecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let t = NaiveTime::from_hms_milli(23, 56, 4, 12);
+    /// assert_eq!(t.hour(), 23);
+    /// assert_eq!(t.minute(), 56);
+    /// assert_eq!(t.second(), 4);
+    /// assert_eq!(t.nanosecond(), 12_000_000);
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_milli(hour: u32, min: u32, sec: u32, milli: u32) -> NaiveTime {
+        NaiveTime::from_hms_milli_opt(hour, min, sec, milli).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute, second and millisecond.
+    ///
+    /// The millisecond part can exceed 1,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Returns `None` on invalid hour, minute, second and/or millisecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let from_hmsm_opt = NaiveTime::from_hms_milli_opt;
+    ///
+    /// assert!(from_hmsm_opt(0, 0, 0, 0).is_some());
+    /// assert!(from_hmsm_opt(23, 59, 59, 999).is_some());
+    /// assert!(from_hmsm_opt(23, 59, 59, 1_999).is_some()); // a leap second after 23:59:59
+    /// assert!(from_hmsm_opt(24, 0, 0, 0).is_none());
+    /// assert!(from_hmsm_opt(23, 60, 0, 0).is_none());
+    /// assert!(from_hmsm_opt(23, 59, 60, 0).is_none());
+    /// assert!(from_hmsm_opt(23, 59, 59, 2_000).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_milli_opt(hour: u32, min: u32, sec: u32, milli: u32) -> Option<NaiveTime> {
+        milli
+            .checked_mul(1_000_000)
+            .and_then(|nano| NaiveTime::from_hms_nano_opt(hour, min, sec, nano))
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute, second and microsecond.
+    ///
+    /// The microsecond part can exceed 1,000,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Panics on invalid hour, minute, second and/or microsecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let t = NaiveTime::from_hms_micro(23, 56, 4, 12_345);
+    /// assert_eq!(t.hour(), 23);
+    /// assert_eq!(t.minute(), 56);
+    /// assert_eq!(t.second(), 4);
+    /// assert_eq!(t.nanosecond(), 12_345_000);
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_micro(hour: u32, min: u32, sec: u32, micro: u32) -> NaiveTime {
+        NaiveTime::from_hms_micro_opt(hour, min, sec, micro).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute, second and microsecond.
+    ///
+    /// The microsecond part can exceed 1,000,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Returns `None` on invalid hour, minute, second and/or microsecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let from_hmsu_opt = NaiveTime::from_hms_micro_opt;
+    ///
+    /// assert!(from_hmsu_opt(0, 0, 0, 0).is_some());
+    /// assert!(from_hmsu_opt(23, 59, 59, 999_999).is_some());
+    /// assert!(from_hmsu_opt(23, 59, 59, 1_999_999).is_some()); // a leap second after 23:59:59
+    /// assert!(from_hmsu_opt(24, 0, 0, 0).is_none());
+    /// assert!(from_hmsu_opt(23, 60, 0, 0).is_none());
+    /// assert!(from_hmsu_opt(23, 59, 60, 0).is_none());
+    /// assert!(from_hmsu_opt(23, 59, 59, 2_000_000).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_micro_opt(hour: u32, min: u32, sec: u32, micro: u32) -> Option<NaiveTime> {
+        micro.checked_mul(1_000).and_then(|nano| NaiveTime::from_hms_nano_opt(hour, min, sec, nano))
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute, second and nanosecond.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Panics on invalid hour, minute, second and/or nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(t.hour(), 23);
+    /// assert_eq!(t.minute(), 56);
+    /// assert_eq!(t.second(), 4);
+    /// assert_eq!(t.nanosecond(), 12_345_678);
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_nano(hour: u32, min: u32, sec: u32, nano: u32) -> NaiveTime {
+        NaiveTime::from_hms_nano_opt(hour, min, sec, nano).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveTime` from hour, minute, second and nanosecond.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Returns `None` on invalid hour, minute, second and/or nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let from_hmsn_opt = NaiveTime::from_hms_nano_opt;
+    ///
+    /// assert!(from_hmsn_opt(0, 0, 0, 0).is_some());
+    /// assert!(from_hmsn_opt(23, 59, 59, 999_999_999).is_some());
+    /// assert!(from_hmsn_opt(23, 59, 59, 1_999_999_999).is_some()); // a leap second after 23:59:59
+    /// assert!(from_hmsn_opt(24, 0, 0, 0).is_none());
+    /// assert!(from_hmsn_opt(23, 60, 0, 0).is_none());
+    /// assert!(from_hmsn_opt(23, 59, 60, 0).is_none());
+    /// assert!(from_hmsn_opt(23, 59, 59, 2_000_000_000).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn from_hms_nano_opt(hour: u32, min: u32, sec: u32, nano: u32) -> Option<NaiveTime> {
+        if hour >= 24 || min >= 60 || sec >= 60 || nano >= 2_000_000_000 {
+            return None;
+        }
+        let secs = hour * 3600 + min * 60 + sec;
+        Some(NaiveTime { secs: secs, frac: nano })
+    }
+
+    /// Makes a new `NaiveTime` from the number of seconds since midnight and nanosecond.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Panics on invalid number of seconds and/or nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let t = NaiveTime::from_num_seconds_from_midnight(86164, 12_345_678);
+    /// assert_eq!(t.hour(), 23);
+    /// assert_eq!(t.minute(), 56);
+    /// assert_eq!(t.second(), 4);
+    /// assert_eq!(t.nanosecond(), 12_345_678);
+    /// ~~~~
+    #[inline]
+    pub fn from_num_seconds_from_midnight(secs: u32, nano: u32) -> NaiveTime {
+        NaiveTime::from_num_seconds_from_midnight_opt(secs, nano).expect("invalid time")
+    }
+
+    /// Makes a new `NaiveTime` from the number of seconds since midnight and nanosecond.
+    ///
+    /// The nanosecond part can exceed 1,000,000,000
+    /// in order to represent the [leap second](#leap-second-handling).
+    ///
+    /// Returns `None` on invalid number of seconds and/or nanosecond.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let from_nsecs_opt = NaiveTime::from_num_seconds_from_midnight_opt;
+    ///
+    /// assert!(from_nsecs_opt(0, 0).is_some());
+    /// assert!(from_nsecs_opt(86399, 999_999_999).is_some());
+    /// assert!(from_nsecs_opt(86399, 1_999_999_999).is_some()); // a leap second after 23:59:59
+    /// assert!(from_nsecs_opt(86_400, 0).is_none());
+    /// assert!(from_nsecs_opt(86399, 2_000_000_000).is_none());
+    /// ~~~~
+    #[inline]
+    pub fn from_num_seconds_from_midnight_opt(secs: u32, nano: u32) -> Option<NaiveTime> {
+        if secs >= 86_400 || nano >= 2_000_000_000 {
+            return None;
+        }
+        Some(NaiveTime { secs: secs, frac: nano })
+    }
+
+    /// Parses a string with the specified format string and returns a new `NaiveTime`.
+    /// See the [`format::strftime` module](../format/strftime/index.html)
+    /// on the supported escape sequences.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let parse_from_str = NaiveTime::parse_from_str;
+    ///
+    /// assert_eq!(parse_from_str("23:56:04", "%H:%M:%S"),
+    ///            Ok(NaiveTime::from_hms(23, 56, 4)));
+    /// assert_eq!(parse_from_str("pm012345.6789", "%p%I%M%S%.f"),
+    ///            Ok(NaiveTime::from_hms_micro(13, 23, 45, 678_900)));
+    /// ~~~~
+    ///
+    /// Date and offset is ignored for the purpose of parsing.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveTime;
+    /// # let parse_from_str = NaiveTime::parse_from_str;
+    /// assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
+    ///            Ok(NaiveTime::from_hms(12, 34, 56)));
+    /// ~~~~
+    ///
+    /// [Leap seconds](#leap-second-handling) are correctly handled by
+    /// treating any time of the form `hh:mm:60` as a leap second.
+    /// (This equally applies to the formatting, so the round trip is possible.)
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveTime;
+    /// # let parse_from_str = NaiveTime::parse_from_str;
+    /// assert_eq!(parse_from_str("08:59:60.123", "%H:%M:%S%.f"),
+    ///            Ok(NaiveTime::from_hms_milli(8, 59, 59, 1_123)));
+    /// ~~~~
+    ///
+    /// Missing seconds are assumed to be zero,
+    /// but out-of-bound times or insufficient fields are errors otherwise.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveTime;
+    /// # let parse_from_str = NaiveTime::parse_from_str;
+    /// assert_eq!(parse_from_str("7:15", "%H:%M"),
+    ///            Ok(NaiveTime::from_hms(7, 15, 0)));
+    ///
+    /// assert!(parse_from_str("04m33s", "%Mm%Ss").is_err());
+    /// assert!(parse_from_str("12", "%H").is_err());
+    /// assert!(parse_from_str("17:60", "%H:%M").is_err());
+    /// assert!(parse_from_str("24:00:00", "%H:%M:%S").is_err());
+    /// ~~~~
+    ///
+    /// All parsed fields should be consistent to each other, otherwise it's an error.
+    /// Here `%H` is for 24-hour clocks, unlike `%I`,
+    /// and thus can be independently determined without AM/PM.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveTime;
+    /// # let parse_from_str = NaiveTime::parse_from_str;
+    /// assert!(parse_from_str("13:07 AM", "%H:%M %p").is_err());
+    /// ~~~~
+    pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveTime> {
+        let mut parsed = Parsed::new();
+        parse(&mut parsed, s, StrftimeItems::new(fmt))?;
+        parsed.to_naive_time()
+    }
+
+    /// Adds given `Duration` to the current time,
+    /// and also returns the number of *seconds*
+    /// in the integral number of days ignored from the addition.
+    /// (We cannot return `Duration` because it is subject to overflow or underflow.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveTime};
+    ///
+    /// let from_hms = NaiveTime::from_hms;
+    ///
+    /// assert_eq!(from_hms(3, 4, 5).overflowing_add_signed(Duration::hours(11)),
+    ///            (from_hms(14, 4, 5), 0));
+    /// assert_eq!(from_hms(3, 4, 5).overflowing_add_signed(Duration::hours(23)),
+    ///            (from_hms(2, 4, 5), 86_400));
+    /// assert_eq!(from_hms(3, 4, 5).overflowing_add_signed(Duration::hours(-7)),
+    ///            (from_hms(20, 4, 5), -86_400));
+    /// # }
+    /// ~~~~
+    #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
+    pub fn overflowing_add_signed(&self, mut rhs: OldDuration) -> (NaiveTime, i64) {
+        let mut secs = self.secs;
+        let mut frac = self.frac;
+
+        // check if `self` is a leap second and adding `rhs` would escape that leap second.
+        // if it's the case, update `self` and `rhs` to involve no leap second;
+        // otherwise the addition immediately finishes.
+        if frac >= 1_000_000_000 {
+            let rfrac = 2_000_000_000 - frac;
+            if rhs >= OldDuration::nanoseconds(i64::from(rfrac)) {
+                rhs = rhs - OldDuration::nanoseconds(i64::from(rfrac));
+                secs += 1;
+                frac = 0;
+            } else if rhs < OldDuration::nanoseconds(-i64::from(frac)) {
+                rhs = rhs + OldDuration::nanoseconds(i64::from(frac));
+                frac = 0;
+            } else {
+                frac = (i64::from(frac) + rhs.num_nanoseconds().unwrap()) as u32;
+                debug_assert!(frac < 2_000_000_000);
+                return (NaiveTime { secs: secs, frac: frac }, 0);
+            }
+        }
+        debug_assert!(secs <= 86_400);
+        debug_assert!(frac < 1_000_000_000);
+
+        let rhssecs = rhs.num_seconds();
+        let rhsfrac = (rhs - OldDuration::seconds(rhssecs)).num_nanoseconds().unwrap();
+        debug_assert_eq!(OldDuration::seconds(rhssecs) + OldDuration::nanoseconds(rhsfrac), rhs);
+        let rhssecsinday = rhssecs % 86_400;
+        let mut morerhssecs = rhssecs - rhssecsinday;
+        let rhssecs = rhssecsinday as i32;
+        let rhsfrac = rhsfrac as i32;
+        debug_assert!(-86_400 < rhssecs && rhssecs < 86_400);
+        debug_assert_eq!(morerhssecs % 86_400, 0);
+        debug_assert!(-1_000_000_000 < rhsfrac && rhsfrac < 1_000_000_000);
+
+        let mut secs = secs as i32 + rhssecs;
+        let mut frac = frac as i32 + rhsfrac;
+        debug_assert!(-86_400 < secs && secs < 2 * 86_400);
+        debug_assert!(-1_000_000_000 < frac && frac < 2_000_000_000);
+
+        if frac < 0 {
+            frac += 1_000_000_000;
+            secs -= 1;
+        } else if frac >= 1_000_000_000 {
+            frac -= 1_000_000_000;
+            secs += 1;
+        }
+        debug_assert!(-86_400 <= secs && secs < 2 * 86_400);
+        debug_assert!(0 <= frac && frac < 1_000_000_000);
+
+        if secs < 0 {
+            secs += 86_400;
+            morerhssecs -= 86_400;
+        } else if secs >= 86_400 {
+            secs -= 86_400;
+            morerhssecs += 86_400;
+        }
+        debug_assert!(0 <= secs && secs < 86_400);
+
+        (NaiveTime { secs: secs as u32, frac: frac as u32 }, morerhssecs)
+    }
+
+    /// Subtracts given `Duration` from the current time,
+    /// and also returns the number of *seconds*
+    /// in the integral number of days ignored from the subtraction.
+    /// (We cannot return `Duration` because it is subject to overflow or underflow.)
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveTime};
+    ///
+    /// let from_hms = NaiveTime::from_hms;
+    ///
+    /// assert_eq!(from_hms(3, 4, 5).overflowing_sub_signed(Duration::hours(2)),
+    ///            (from_hms(1, 4, 5), 0));
+    /// assert_eq!(from_hms(3, 4, 5).overflowing_sub_signed(Duration::hours(17)),
+    ///            (from_hms(10, 4, 5), 86_400));
+    /// assert_eq!(from_hms(3, 4, 5).overflowing_sub_signed(Duration::hours(-22)),
+    ///            (from_hms(1, 4, 5), -86_400));
+    /// # }
+    /// ~~~~
+    #[inline]
+    pub fn overflowing_sub_signed(&self, rhs: OldDuration) -> (NaiveTime, i64) {
+        let (time, rhs) = self.overflowing_add_signed(-rhs);
+        (time, -rhs) // safe to negate, rhs is within +/- (2^63 / 1000)
+    }
+
+    /// Subtracts another `NaiveTime` from the current time.
+    /// Returns a `Duration` within +/- 1 day.
+    /// This does not overflow or underflow at all.
+    ///
+    /// As a part of Chrono's [leap second handling](#leap-second-handling),
+    /// the subtraction assumes that **there is no leap second ever**,
+    /// except when any of the `NaiveTime`s themselves represents a leap second
+    /// in which case the assumption becomes that
+    /// **there are exactly one (or two) leap second(s) ever**.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// use chrono::{Duration, NaiveTime};
+    ///
+    /// let from_hmsm = NaiveTime::from_hms_milli;
+    /// let since = NaiveTime::signed_duration_since;
+    ///
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 7, 900)),
+    ///            Duration::zero());
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 7, 875)),
+    ///            Duration::milliseconds(25));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 6, 925)),
+    ///            Duration::milliseconds(975));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 0, 900)),
+    ///            Duration::seconds(7));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 0, 7, 900)),
+    ///            Duration::seconds(5 * 60));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(0, 5, 7, 900)),
+    ///            Duration::seconds(3 * 3600));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(4, 5, 7, 900)),
+    ///            Duration::seconds(-3600));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(2, 4, 6, 800)),
+    ///            Duration::seconds(3600 + 60 + 1) + Duration::milliseconds(100));
+    /// # }
+    /// ~~~~
+    ///
+    /// Leap seconds are handled, but the subtraction assumes that
+    /// there were no other leap seconds happened.
+    ///
+    /// ~~~~
+    /// # extern crate chrono; fn main() {
+    /// # use chrono::{Duration, NaiveTime};
+    /// # let from_hmsm = NaiveTime::from_hms_milli;
+    /// # let since = NaiveTime::signed_duration_since;
+    /// assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(3, 0, 59, 0)),
+    ///            Duration::seconds(1));
+    /// assert_eq!(since(from_hmsm(3, 0, 59, 1_500), from_hmsm(3, 0, 59, 0)),
+    ///            Duration::milliseconds(1500));
+    /// assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(3, 0, 0, 0)),
+    ///            Duration::seconds(60));
+    /// assert_eq!(since(from_hmsm(3, 0, 0, 0), from_hmsm(2, 59, 59, 1_000)),
+    ///            Duration::seconds(1));
+    /// assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(2, 59, 59, 1_000)),
+    ///            Duration::seconds(61));
+    /// # }
+    /// ~~~~
+    pub fn signed_duration_since(self, rhs: NaiveTime) -> OldDuration {
+        //     |    |    :leap|    |    |    |    |    |    |    :leap|    |
+        //     |    |    :    |    |    |    |    |    |    |    :    |    |
+        // ----+----+-----*---+----+----+----+----+----+----+-------*-+----+----
+        //          |   `rhs` |                             |    `self`
+        //          |======================================>|       |
+        //          |     |  `self.secs - rhs.secs`         |`self.frac`
+        //          |====>|   |                             |======>|
+        //      `rhs.frac`|========================================>|
+        //          |     |   |        `self - rhs`         |       |
+
+        use core::cmp::Ordering;
+
+        let secs = i64::from(self.secs) - i64::from(rhs.secs);
+        let frac = i64::from(self.frac) - i64::from(rhs.frac);
+
+        // `secs` may contain a leap second yet to be counted
+        let adjust = match self.secs.cmp(&rhs.secs) {
+            Ordering::Greater => {
+                if rhs.frac >= 1_000_000_000 {
+                    1
+                } else {
+                    0
+                }
+            }
+            Ordering::Equal => 0,
+            Ordering::Less => {
+                if self.frac >= 1_000_000_000 {
+                    -1
+                } else {
+                    0
+                }
+            }
+        };
+
+        OldDuration::seconds(secs + adjust) + OldDuration::nanoseconds(frac)
+    }
+
+    /// Formats the time with the specified formatting items.
+    /// Otherwise it is the same as the ordinary [`format`](#method.format) method.
+    ///
+    /// The `Iterator` of items should be `Clone`able,
+    /// since the resulting `DelayedFormat` value may be formatted multiple times.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    /// use chrono::format::strftime::StrftimeItems;
+    ///
+    /// let fmt = StrftimeItems::new("%H:%M:%S");
+    /// let t = NaiveTime::from_hms(23, 56, 4);
+    /// assert_eq!(t.format_with_items(fmt.clone()).to_string(), "23:56:04");
+    /// assert_eq!(t.format("%H:%M:%S").to_string(),             "23:56:04");
+    /// ~~~~
+    ///
+    /// The resulting `DelayedFormat` can be formatted directly via the `Display` trait.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveTime;
+    /// # use chrono::format::strftime::StrftimeItems;
+    /// # let fmt = StrftimeItems::new("%H:%M:%S").clone();
+    /// # let t = NaiveTime::from_hms(23, 56, 4);
+    /// assert_eq!(format!("{}", t.format_with_items(fmt)), "23:56:04");
+    /// ~~~~
+    #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
+    pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
+    where
+        I: Iterator<Item = B> + Clone,
+        B: Borrow<Item<'a>>,
+    {
+        DelayedFormat::new(None, Some(*self), items)
+    }
+
+    /// Formats the time with the specified format string.
+    /// See the [`format::strftime` module](../format/strftime/index.html)
+    /// on the supported escape sequences.
+    ///
+    /// This returns a `DelayedFormat`,
+    /// which gets converted to a string only when actual formatting happens.
+    /// You may use the `to_string` method to get a `String`,
+    /// or just feed it into `print!` and other formatting macros.
+    /// (In this way it avoids the redundant memory allocation.)
+    ///
+    /// A wrong format string does *not* issue an error immediately.
+    /// Rather, converting or formatting the `DelayedFormat` fails.
+    /// You are recommended to immediately use `DelayedFormat` for this reason.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::NaiveTime;
+    ///
+    /// let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(t.format("%H:%M:%S").to_string(), "23:56:04");
+    /// assert_eq!(t.format("%H:%M:%S%.6f").to_string(), "23:56:04.012345");
+    /// assert_eq!(t.format("%-I:%M %p").to_string(), "11:56 PM");
+    /// ~~~~
+    ///
+    /// The resulting `DelayedFormat` can be formatted directly via the `Display` trait.
+    ///
+    /// ~~~~
+    /// # use chrono::NaiveTime;
+    /// # let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(format!("{}", t.format("%H:%M:%S")), "23:56:04");
+    /// assert_eq!(format!("{}", t.format("%H:%M:%S%.6f")), "23:56:04.012345");
+    /// assert_eq!(format!("{}", t.format("%-I:%M %p")), "11:56 PM");
+    /// ~~~~
+    #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
+    pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
+        self.format_with_items(StrftimeItems::new(fmt))
+    }
+
+    /// Returns a triple of the hour, minute and second numbers.
+    fn hms(&self) -> (u32, u32, u32) {
+        let (mins, sec) = div_mod_floor(self.secs, 60);
+        let (hour, min) = div_mod_floor(mins, 60);
+        (hour, min, sec)
+    }
+}
+
+impl Timelike for NaiveTime {
+    /// Returns the hour number from 0 to 23.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// assert_eq!(NaiveTime::from_hms(0, 0, 0).hour(), 0);
+    /// assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).hour(), 23);
+    /// ~~~~
+    #[inline]
+    fn hour(&self) -> u32 {
+        self.hms().0
+    }
+
+    /// Returns the minute number from 0 to 59.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// assert_eq!(NaiveTime::from_hms(0, 0, 0).minute(), 0);
+    /// assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).minute(), 56);
+    /// ~~~~
+    #[inline]
+    fn minute(&self) -> u32 {
+        self.hms().1
+    }
+
+    /// Returns the second number from 0 to 59.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// assert_eq!(NaiveTime::from_hms(0, 0, 0).second(), 0);
+    /// assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).second(), 4);
+    /// ~~~~
+    ///
+    /// This method never returns 60 even when it is a leap second.
+    /// ([Why?](#leap-second-handling))
+    /// Use the proper [formatting method](#method.format) to get a human-readable representation.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveTime, Timelike};
+    /// let leap = NaiveTime::from_hms_milli(23, 59, 59, 1_000);
+    /// assert_eq!(leap.second(), 59);
+    /// assert_eq!(leap.format("%H:%M:%S").to_string(), "23:59:60");
+    /// ~~~~
+    #[inline]
+    fn second(&self) -> u32 {
+        self.hms().2
+    }
+
+    /// Returns the number of nanoseconds since the whole non-leap second.
+    /// The range from 1,000,000,000 to 1,999,999,999 represents
+    /// the [leap second](#leap-second-handling).
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// assert_eq!(NaiveTime::from_hms(0, 0, 0).nanosecond(), 0);
+    /// assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).nanosecond(), 12_345_678);
+    /// ~~~~
+    ///
+    /// Leap seconds may have seemingly out-of-range return values.
+    /// You can reduce the range with `time.nanosecond() % 1_000_000_000`, or
+    /// use the proper [formatting method](#method.format) to get a human-readable representation.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveTime, Timelike};
+    /// let leap = NaiveTime::from_hms_milli(23, 59, 59, 1_000);
+    /// assert_eq!(leap.nanosecond(), 1_000_000_000);
+    /// assert_eq!(leap.format("%H:%M:%S%.9f").to_string(), "23:59:60.000000000");
+    /// ~~~~
+    #[inline]
+    fn nanosecond(&self) -> u32 {
+        self.frac
+    }
+
+    /// Makes a new `NaiveTime` with the hour number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveTime` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(dt.with_hour(7), Some(NaiveTime::from_hms_nano(7, 56, 4, 12_345_678)));
+    /// assert_eq!(dt.with_hour(24), None);
+    /// ~~~~
+    #[inline]
+    fn with_hour(&self, hour: u32) -> Option<NaiveTime> {
+        if hour >= 24 {
+            return None;
+        }
+        let secs = hour * 3600 + self.secs % 3600;
+        Some(NaiveTime { secs: secs, ..*self })
+    }
+
+    /// Makes a new `NaiveTime` with the minute number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveTime` would be invalid.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(dt.with_minute(45), Some(NaiveTime::from_hms_nano(23, 45, 4, 12_345_678)));
+    /// assert_eq!(dt.with_minute(60), None);
+    /// ~~~~
+    #[inline]
+    fn with_minute(&self, min: u32) -> Option<NaiveTime> {
+        if min >= 60 {
+            return None;
+        }
+        let secs = self.secs / 3600 * 3600 + min * 60 + self.secs % 60;
+        Some(NaiveTime { secs: secs, ..*self })
+    }
+
+    /// Makes a new `NaiveTime` with the second number changed.
+    ///
+    /// Returns `None` when the resulting `NaiveTime` would be invalid.
+    /// As with the [`second`](#method.second) method,
+    /// the input range is restricted to 0 through 59.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(dt.with_second(17), Some(NaiveTime::from_hms_nano(23, 56, 17, 12_345_678)));
+    /// assert_eq!(dt.with_second(60), None);
+    /// ~~~~
+    #[inline]
+    fn with_second(&self, sec: u32) -> Option<NaiveTime> {
+        if sec >= 60 {
+            return None;
+        }
+        let secs = self.secs / 60 * 60 + sec;
+        Some(NaiveTime { secs: secs, ..*self })
+    }
+
+    /// Makes a new `NaiveTime` with nanoseconds since the whole non-leap second changed.
+    ///
+    /// Returns `None` when the resulting `NaiveTime` would be invalid.
+    /// As with the [`nanosecond`](#method.nanosecond) method,
+    /// the input range can exceed 1,000,000,000 for leap seconds.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(dt.with_nanosecond(333_333_333),
+    ///            Some(NaiveTime::from_hms_nano(23, 56, 4, 333_333_333)));
+    /// assert_eq!(dt.with_nanosecond(2_000_000_000), None);
+    /// ~~~~
+    ///
+    /// Leap seconds can theoretically follow *any* whole second.
+    /// The following would be a proper leap second at the time zone offset of UTC-00:03:57
+    /// (there are several historical examples comparable to this "non-sense" offset),
+    /// and therefore is allowed.
+    ///
+    /// ~~~~
+    /// # use chrono::{NaiveTime, Timelike};
+    /// # let dt = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+    /// assert_eq!(dt.with_nanosecond(1_333_333_333),
+    ///            Some(NaiveTime::from_hms_nano(23, 56, 4, 1_333_333_333)));
+    /// ~~~~
+    #[inline]
+    fn with_nanosecond(&self, nano: u32) -> Option<NaiveTime> {
+        if nano >= 2_000_000_000 {
+            return None;
+        }
+        Some(NaiveTime { frac: nano, ..*self })
+    }
+
+    /// Returns the number of non-leap seconds past the last midnight.
+    ///
+    /// # Example
+    ///
+    /// ~~~~
+    /// use chrono::{NaiveTime, Timelike};
+    ///
+    /// assert_eq!(NaiveTime::from_hms(1, 2, 3).num_seconds_from_midnight(),
+    ///            3723);
+    /// assert_eq!(NaiveTime::from_hms_nano(23, 56, 4, 12_345_678).num_seconds_from_midnight(),
+    ///            86164);
+    /// assert_eq!(NaiveTime::from_hms_milli(23, 59, 59, 1_000).num_seconds_from_midnight(),
+    ///            86399);
+    /// ~~~~
+    #[inline]
+    fn num_seconds_from_midnight(&self) -> u32 {
+        self.secs // do not repeat the calculation!
+    }
+}
+
+/// `NaiveTime` can be used as a key to the hash maps (in principle).
+///
+/// Practically this also takes account of fractional seconds, so it is not recommended.
+/// (For the obvious reason this also distinguishes leap seconds from non-leap seconds.)
+impl hash::Hash for NaiveTime {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.secs.hash(state);
+        self.frac.hash(state);
+    }
+}
+
+/// An addition of `Duration` to `NaiveTime` wraps around and never overflows or underflows.
+/// In particular the addition ignores integral number of days.
+///
+/// As a part of Chrono's [leap second handling](#leap-second-handling),
+/// the addition assumes that **there is no leap second ever**,
+/// except when the `NaiveTime` itself represents a leap second
+/// in which case the assumption becomes that **there is exactly a single leap second ever**.
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveTime};
+///
+/// let from_hmsm = NaiveTime::from_hms_milli;
+///
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::zero(),                  from_hmsm(3, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(1),              from_hmsm(3, 5, 8, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-1),             from_hmsm(3, 5, 6, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(60 + 4),         from_hmsm(3, 6, 11, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(7*60*60 - 6*60), from_hmsm(9, 59, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::milliseconds(80),        from_hmsm(3, 5, 7, 80));
+/// assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(280),     from_hmsm(3, 5, 8, 230));
+/// assert_eq!(from_hmsm(3, 5, 7, 950) + Duration::milliseconds(-980),    from_hmsm(3, 5, 6, 970));
+/// # }
+/// ~~~~
+///
+/// The addition wraps around.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveTime};
+/// # let from_hmsm = NaiveTime::from_hms_milli;
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(22*60*60), from_hmsm(1, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::seconds(-8*60*60), from_hmsm(19, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + Duration::days(800),         from_hmsm(3, 5, 7, 0));
+/// # }
+/// ~~~~
+///
+/// Leap seconds are handled, but the addition assumes that it is the only leap second happened.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveTime};
+/// # let from_hmsm = NaiveTime::from_hms_milli;
+/// let leap = from_hmsm(3, 5, 59, 1_300);
+/// assert_eq!(leap + Duration::zero(),             from_hmsm(3, 5, 59, 1_300));
+/// assert_eq!(leap + Duration::milliseconds(-500), from_hmsm(3, 5, 59, 800));
+/// assert_eq!(leap + Duration::milliseconds(500),  from_hmsm(3, 5, 59, 1_800));
+/// assert_eq!(leap + Duration::milliseconds(800),  from_hmsm(3, 6, 0, 100));
+/// assert_eq!(leap + Duration::seconds(10),        from_hmsm(3, 6, 9, 300));
+/// assert_eq!(leap + Duration::seconds(-10),       from_hmsm(3, 5, 50, 300));
+/// assert_eq!(leap + Duration::days(1),            from_hmsm(3, 5, 59, 300));
+/// # }
+/// ~~~~
+impl Add<OldDuration> for NaiveTime {
+    type Output = NaiveTime;
+
+    #[inline]
+    fn add(self, rhs: OldDuration) -> NaiveTime {
+        self.overflowing_add_signed(rhs).0
+    }
+}
+
+impl AddAssign<OldDuration> for NaiveTime {
+    #[inline]
+    fn add_assign(&mut self, rhs: OldDuration) {
+        *self = self.add(rhs);
+    }
+}
+
+/// A subtraction of `Duration` from `NaiveTime` wraps around and never overflows or underflows.
+/// In particular the addition ignores integral number of days.
+/// It is the same as the addition with a negated `Duration`.
+///
+/// As a part of Chrono's [leap second handling](#leap-second-handling),
+/// the addition assumes that **there is no leap second ever**,
+/// except when the `NaiveTime` itself represents a leap second
+/// in which case the assumption becomes that **there is exactly a single leap second ever**.
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveTime};
+///
+/// let from_hmsm = NaiveTime::from_hms_milli;
+///
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::zero(),                  from_hmsm(3, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(1),              from_hmsm(3, 5, 6, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(60 + 5),         from_hmsm(3, 4, 2, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(2*60*60 + 6*60), from_hmsm(0, 59, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::milliseconds(80),        from_hmsm(3, 5, 6, 920));
+/// assert_eq!(from_hmsm(3, 5, 7, 950) - Duration::milliseconds(280),     from_hmsm(3, 5, 7, 670));
+/// # }
+/// ~~~~
+///
+/// The subtraction wraps around.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveTime};
+/// # let from_hmsm = NaiveTime::from_hms_milli;
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(8*60*60), from_hmsm(19, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::days(800),        from_hmsm(3, 5, 7, 0));
+/// # }
+/// ~~~~
+///
+/// Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveTime};
+/// # let from_hmsm = NaiveTime::from_hms_milli;
+/// let leap = from_hmsm(3, 5, 59, 1_300);
+/// assert_eq!(leap - Duration::zero(),            from_hmsm(3, 5, 59, 1_300));
+/// assert_eq!(leap - Duration::milliseconds(200), from_hmsm(3, 5, 59, 1_100));
+/// assert_eq!(leap - Duration::milliseconds(500), from_hmsm(3, 5, 59, 800));
+/// assert_eq!(leap - Duration::seconds(60),       from_hmsm(3, 5, 0, 300));
+/// assert_eq!(leap - Duration::days(1),           from_hmsm(3, 6, 0, 300));
+/// # }
+/// ~~~~
+impl Sub<OldDuration> for NaiveTime {
+    type Output = NaiveTime;
+
+    #[inline]
+    fn sub(self, rhs: OldDuration) -> NaiveTime {
+        self.overflowing_sub_signed(rhs).0
+    }
+}
+
+impl SubAssign<OldDuration> for NaiveTime {
+    #[inline]
+    fn sub_assign(&mut self, rhs: OldDuration) {
+        *self = self.sub(rhs);
+    }
+}
+
+/// Subtracts another `NaiveTime` from the current time.
+/// Returns a `Duration` within +/- 1 day.
+/// This does not overflow or underflow at all.
+///
+/// As a part of Chrono's [leap second handling](#leap-second-handling),
+/// the subtraction assumes that **there is no leap second ever**,
+/// except when any of the `NaiveTime`s themselves represents a leap second
+/// in which case the assumption becomes that
+/// **there are exactly one (or two) leap second(s) ever**.
+///
+/// The implementation is a wrapper around
+/// [`NaiveTime::signed_duration_since`](#method.signed_duration_since).
+///
+/// # Example
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// use chrono::{Duration, NaiveTime};
+///
+/// let from_hmsm = NaiveTime::from_hms_milli;
+///
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 900), Duration::zero());
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 875), Duration::milliseconds(25));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 6, 925), Duration::milliseconds(975));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 0, 900), Duration::seconds(7));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 0, 7, 900), Duration::seconds(5 * 60));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(0, 5, 7, 900), Duration::seconds(3 * 3600));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(4, 5, 7, 900), Duration::seconds(-3600));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(2, 4, 6, 800),
+///            Duration::seconds(3600 + 60 + 1) + Duration::milliseconds(100));
+/// # }
+/// ~~~~
+///
+/// Leap seconds are handled, but the subtraction assumes that
+/// there were no other leap seconds happened.
+///
+/// ~~~~
+/// # extern crate chrono; fn main() {
+/// # use chrono::{Duration, NaiveTime};
+/// # let from_hmsm = NaiveTime::from_hms_milli;
+/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 59, 0), Duration::seconds(1));
+/// assert_eq!(from_hmsm(3, 0, 59, 1_500) - from_hmsm(3, 0, 59, 0),
+///            Duration::milliseconds(1500));
+/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 0, 0), Duration::seconds(60));
+/// assert_eq!(from_hmsm(3, 0, 0, 0) - from_hmsm(2, 59, 59, 1_000), Duration::seconds(1));
+/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(2, 59, 59, 1_000),
+///            Duration::seconds(61));
+/// # }
+/// ~~~~
+impl Sub<NaiveTime> for NaiveTime {
+    type Output = OldDuration;
+
+    #[inline]
+    fn sub(self, rhs: NaiveTime) -> OldDuration {
+        self.signed_duration_since(rhs)
+    }
+}
+
+/// The `Debug` output of the naive time `t` is the same as
+/// [`t.format("%H:%M:%S%.f")`](../format/strftime/index.html).
+///
+/// The string printed can be readily parsed via the `parse` method on `str`.
+///
+/// It should be noted that, for leap seconds not on the minute boundary,
+/// it may print a representation not distinguishable from non-leap seconds.
+/// This doesn't matter in practice, since such leap seconds never happened.
+/// (By the time of the first leap second on 1972-06-30,
+/// every time zone offset around the world has standardized to the 5-minute alignment.)
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveTime;
+///
+/// assert_eq!(format!("{:?}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
+/// assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
+/// assert_eq!(format!("{:?}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
+/// assert_eq!(format!("{:?}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");
+/// ~~~~
+///
+/// Leap seconds may also be used.
+///
+/// ~~~~
+/// # use chrono::NaiveTime;
+/// assert_eq!(format!("{:?}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");
+/// ~~~~
+impl fmt::Debug for NaiveTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let (hour, min, sec) = self.hms();
+        let (sec, nano) = if self.frac >= 1_000_000_000 {
+            (sec + 1, self.frac - 1_000_000_000)
+        } else {
+            (sec, self.frac)
+        };
+
+        write!(f, "{:02}:{:02}:{:02}", hour, min, sec)?;
+        if nano == 0 {
+            Ok(())
+        } else if nano % 1_000_000 == 0 {
+            write!(f, ".{:03}", nano / 1_000_000)
+        } else if nano % 1_000 == 0 {
+            write!(f, ".{:06}", nano / 1_000)
+        } else {
+            write!(f, ".{:09}", nano)
+        }
+    }
+}
+
+/// The `Display` output of the naive time `t` is the same as
+/// [`t.format("%H:%M:%S%.f")`](../format/strftime/index.html).
+///
+/// The string printed can be readily parsed via the `parse` method on `str`.
+///
+/// It should be noted that, for leap seconds not on the minute boundary,
+/// it may print a representation not distinguishable from non-leap seconds.
+/// This doesn't matter in practice, since such leap seconds never happened.
+/// (By the time of the first leap second on 1972-06-30,
+/// every time zone offset around the world has standardized to the 5-minute alignment.)
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveTime;
+///
+/// assert_eq!(format!("{}", NaiveTime::from_hms(23, 56, 4)),              "23:56:04");
+/// assert_eq!(format!("{}", NaiveTime::from_hms_milli(23, 56, 4, 12)),    "23:56:04.012");
+/// assert_eq!(format!("{}", NaiveTime::from_hms_micro(23, 56, 4, 1234)),  "23:56:04.001234");
+/// assert_eq!(format!("{}", NaiveTime::from_hms_nano(23, 56, 4, 123456)), "23:56:04.000123456");
+/// ~~~~
+///
+/// Leap seconds may also be used.
+///
+/// ~~~~
+/// # use chrono::NaiveTime;
+/// assert_eq!(format!("{}", NaiveTime::from_hms_milli(6, 59, 59, 1_500)), "06:59:60.500");
+/// ~~~~
+impl fmt::Display for NaiveTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
+
+/// Parsing a `str` into a `NaiveTime` uses the same format,
+/// [`%H:%M:%S%.f`](../format/strftime/index.html), as in `Debug` and `Display`.
+///
+/// # Example
+///
+/// ~~~~
+/// use chrono::NaiveTime;
+///
+/// let t = NaiveTime::from_hms(23, 56, 4);
+/// assert_eq!("23:56:04".parse::<NaiveTime>(), Ok(t));
+///
+/// let t = NaiveTime::from_hms_nano(23, 56, 4, 12_345_678);
+/// assert_eq!("23:56:4.012345678".parse::<NaiveTime>(), Ok(t));
+///
+/// let t = NaiveTime::from_hms_nano(23, 59, 59, 1_234_567_890); // leap second
+/// assert_eq!("23:59:60.23456789".parse::<NaiveTime>(), Ok(t));
+///
+/// assert!("foo".parse::<NaiveTime>().is_err());
+/// ~~~~
+impl str::FromStr for NaiveTime {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> ParseResult<NaiveTime> {
+        const ITEMS: &'static [Item<'static>] = &[
+            Item::Numeric(Numeric::Hour, Pad::Zero),
+            Item::Space(""),
+            Item::Literal(":"),
+            Item::Numeric(Numeric::Minute, Pad::Zero),
+            Item::Space(""),
+            Item::Literal(":"),
+            Item::Numeric(Numeric::Second, Pad::Zero),
+            Item::Fixed(Fixed::Nanosecond),
+            Item::Space(""),
+        ];
+
+        let mut parsed = Parsed::new();
+        parse(&mut parsed, s, ITEMS.iter())?;
+        parsed.to_naive_time()
+    }
+}
+
+#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))]
+fn test_encodable_json<F, E>(to_string: F)
+where
+    F: Fn(&NaiveTime) -> Result<String, E>,
+    E: ::std::fmt::Debug,
+{
+    assert_eq!(to_string(&NaiveTime::from_hms(0, 0, 0)).ok(), Some(r#""00:00:00""#.into()));
+    assert_eq!(
+        to_string(&NaiveTime::from_hms_milli(0, 0, 0, 950)).ok(),
+        Some(r#""00:00:00.950""#.into())
+    );
+    assert_eq!(
+        to_string(&NaiveTime::from_hms_milli(0, 0, 59, 1_000)).ok(),
+        Some(r#""00:00:60""#.into())
+    );
+    assert_eq!(to_string(&NaiveTime::from_hms(0, 1, 2)).ok(), Some(r#""00:01:02""#.into()));
+    assert_eq!(
+        to_string(&NaiveTime::from_hms_nano(3, 5, 7, 98765432)).ok(),
+        Some(r#""03:05:07.098765432""#.into())
+    );
+    assert_eq!(to_string(&NaiveTime::from_hms(7, 8, 9)).ok(), Some(r#""07:08:09""#.into()));
+    assert_eq!(
+        to_string(&NaiveTime::from_hms_micro(12, 34, 56, 789)).ok(),
+        Some(r#""12:34:56.000789""#.into())
+    );
+    assert_eq!(
+        to_string(&NaiveTime::from_hms_nano(23, 59, 59, 1_999_999_999)).ok(),
+        Some(r#""23:59:60.999999999""#.into())
+    );
+}
+
+#[cfg(all(test, any(feature = "rustc-serialize", feature = "serde")))]
+fn test_decodable_json<F, E>(from_str: F)
+where
+    F: Fn(&str) -> Result<NaiveTime, E>,
+    E: ::std::fmt::Debug,
+{
+    assert_eq!(from_str(r#""00:00:00""#).ok(), Some(NaiveTime::from_hms(0, 0, 0)));
+    assert_eq!(from_str(r#""0:0:0""#).ok(), Some(NaiveTime::from_hms(0, 0, 0)));
+    assert_eq!(from_str(r#""00:00:00.950""#).ok(), Some(NaiveTime::from_hms_milli(0, 0, 0, 950)));
+    assert_eq!(from_str(r#""0:0:0.95""#).ok(), Some(NaiveTime::from_hms_milli(0, 0, 0, 950)));
+    assert_eq!(from_str(r#""00:00:60""#).ok(), Some(NaiveTime::from_hms_milli(0, 0, 59, 1_000)));
+    assert_eq!(from_str(r#""00:01:02""#).ok(), Some(NaiveTime::from_hms(0, 1, 2)));
+    assert_eq!(
+        from_str(r#""03:05:07.098765432""#).ok(),
+        Some(NaiveTime::from_hms_nano(3, 5, 7, 98765432))
+    );
+    assert_eq!(from_str(r#""07:08:09""#).ok(), Some(NaiveTime::from_hms(7, 8, 9)));
+    assert_eq!(
+        from_str(r#""12:34:56.000789""#).ok(),
+        Some(NaiveTime::from_hms_micro(12, 34, 56, 789))
+    );
+    assert_eq!(
+        from_str(r#""23:59:60.999999999""#).ok(),
+        Some(NaiveTime::from_hms_nano(23, 59, 59, 1_999_999_999))
+    );
+    assert_eq!(
+        from_str(r#""23:59:60.9999999999997""#).ok(), // excess digits are ignored
+        Some(NaiveTime::from_hms_nano(23, 59, 59, 1_999_999_999))
+    );
+
+    // bad formats
+    assert!(from_str(r#""""#).is_err());
+    assert!(from_str(r#""000000""#).is_err());
+    assert!(from_str(r#""00:00:61""#).is_err());
+    assert!(from_str(r#""00:60:00""#).is_err());
+    assert!(from_str(r#""24:00:00""#).is_err());
+    assert!(from_str(r#""23:59:59,1""#).is_err());
+    assert!(from_str(r#""012:34:56""#).is_err());
+    assert!(from_str(r#""hh:mm:ss""#).is_err());
+    assert!(from_str(r#"0"#).is_err());
+    assert!(from_str(r#"86399"#).is_err());
+    assert!(from_str(r#"{}"#).is_err());
+    // pre-0.3.0 rustc-serialize format is now invalid
+    assert!(from_str(r#"{"secs":0,"frac":0}"#).is_err());
+    assert!(from_str(r#"null"#).is_err());
+}
+
+#[cfg(feature = "rustc-serialize")]
+mod rustc_serialize {
+    use super::NaiveTime;
+    use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+
+    impl Encodable for NaiveTime {
+        fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+            format!("{:?}", self).encode(s)
+        }
+    }
+
+    impl Decodable for NaiveTime {
+        fn decode<D: Decoder>(d: &mut D) -> Result<NaiveTime, D::Error> {
+            d.read_str()?.parse().map_err(|_| d.error("invalid time"))
+        }
+    }
+
+    #[cfg(test)]
+    use rustc_serialize::json;
+
+    #[test]
+    fn test_encodable() {
+        super::test_encodable_json(json::encode);
+    }
+
+    #[test]
+    fn test_decodable() {
+        super::test_decodable_json(json::decode);
+    }
+}
+
+#[cfg(feature = "serde")]
+mod serde {
+    use super::NaiveTime;
+    use core::fmt;
+    use serdelib::{de, ser};
+
+    // TODO not very optimized for space (binary formats would want something better)
+    // TODO round-trip for general leap seconds (not just those with second = 60)
+
+    impl ser::Serialize for NaiveTime {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: ser::Serializer,
+        {
+            serializer.collect_str(&self)
+        }
+    }
+
+    struct NaiveTimeVisitor;
+
+    impl<'de> de::Visitor<'de> for NaiveTimeVisitor {
+        type Value = NaiveTime;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            write!(formatter, "a formatted time string")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<NaiveTime, E>
+        where
+            E: de::Error,
+        {
+            value.parse().map_err(E::custom)
+        }
+    }
+
+    impl<'de> de::Deserialize<'de> for NaiveTime {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            deserializer.deserialize_str(NaiveTimeVisitor)
+        }
+    }
+
+    #[cfg(test)]
+    extern crate bincode;
+    #[cfg(test)]
+    extern crate serde_json;
+
+    #[test]
+    fn test_serde_serialize() {
+        super::test_encodable_json(self::serde_json::to_string);
+    }
+
+    #[test]
+    fn test_serde_deserialize() {
+        super::test_decodable_json(|input| self::serde_json::from_str(&input));
+    }
+
+    #[test]
+    fn test_serde_bincode() {
+        // Bincode is relevant to test separately from JSON because
+        // it is not self-describing.
+        use self::bincode::{deserialize, serialize, Infinite};
+
+        let t = NaiveTime::from_hms_nano(3, 5, 7, 98765432);
+        let encoded = serialize(&t, Infinite).unwrap();
+        let decoded: NaiveTime = deserialize(&encoded).unwrap();
+        assert_eq!(t, decoded);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::NaiveTime;
+    use oldtime::Duration;
+    use std::u32;
+    use Timelike;
+
+    #[test]
+    fn test_time_from_hms_milli() {
+        assert_eq!(
+            NaiveTime::from_hms_milli_opt(3, 5, 7, 0),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 0))
+        );
+        assert_eq!(
+            NaiveTime::from_hms_milli_opt(3, 5, 7, 777),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 777_000_000))
+        );
+        assert_eq!(
+            NaiveTime::from_hms_milli_opt(3, 5, 7, 1_999),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 1_999_000_000))
+        );
+        assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 2_000), None);
+        assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, 5_000), None); // overflow check
+        assert_eq!(NaiveTime::from_hms_milli_opt(3, 5, 7, u32::MAX), None);
+    }
+
+    #[test]
+    fn test_time_from_hms_micro() {
+        assert_eq!(
+            NaiveTime::from_hms_micro_opt(3, 5, 7, 0),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 0))
+        );
+        assert_eq!(
+            NaiveTime::from_hms_micro_opt(3, 5, 7, 333),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 333_000))
+        );
+        assert_eq!(
+            NaiveTime::from_hms_micro_opt(3, 5, 7, 777_777),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 777_777_000))
+        );
+        assert_eq!(
+            NaiveTime::from_hms_micro_opt(3, 5, 7, 1_999_999),
+            Some(NaiveTime::from_hms_nano(3, 5, 7, 1_999_999_000))
+        );
+        assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 2_000_000), None);
+        assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, 5_000_000), None); // overflow check
+        assert_eq!(NaiveTime::from_hms_micro_opt(3, 5, 7, u32::MAX), None);
+    }
+
+    #[test]
+    fn test_time_hms() {
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).hour(), 3);
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(0), Some(NaiveTime::from_hms(0, 5, 7)));
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(23), Some(NaiveTime::from_hms(23, 5, 7)));
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(24), None);
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_hour(u32::MAX), None);
+
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).minute(), 5);
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(0), Some(NaiveTime::from_hms(3, 0, 7)));
+        assert_eq!(
+            NaiveTime::from_hms(3, 5, 7).with_minute(59),
+            Some(NaiveTime::from_hms(3, 59, 7))
+        );
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(60), None);
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_minute(u32::MAX), None);
+
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).second(), 7);
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(0), Some(NaiveTime::from_hms(3, 5, 0)));
+        assert_eq!(
+            NaiveTime::from_hms(3, 5, 7).with_second(59),
+            Some(NaiveTime::from_hms(3, 5, 59))
+        );
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(60), None);
+        assert_eq!(NaiveTime::from_hms(3, 5, 7).with_second(u32::MAX), None);
+    }
+
+    #[test]
+    fn test_time_add() {
+        macro_rules! check {
+            ($lhs:expr, $rhs:expr, $sum:expr) => {{
+                assert_eq!($lhs + $rhs, $sum);
+                //assert_eq!($rhs + $lhs, $sum);
+            }};
+        }
+
+        let hmsm = |h, m, s, mi| NaiveTime::from_hms_milli(h, m, s, mi);
+
+        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));
+        check!(hmsm(3, 5, 7, 1_300), Duration::milliseconds(-1800), hmsm(3, 5, 6, 500));
+        check!(hmsm(3, 5, 7, 1_300), Duration::milliseconds(-800), hmsm(3, 5, 7, 500));
+        check!(hmsm(3, 5, 7, 1_300), Duration::milliseconds(-100), hmsm(3, 5, 7, 1_200));
+        check!(hmsm(3, 5, 7, 1_300), Duration::milliseconds(100), hmsm(3, 5, 7, 1_400));
+        check!(hmsm(3, 5, 7, 1_300), Duration::milliseconds(800), hmsm(3, 5, 8, 100));
+        check!(hmsm(3, 5, 7, 1_300), Duration::milliseconds(1800), hmsm(3, 5, 9, 100));
+        check!(hmsm(3, 5, 7, 900), Duration::seconds(86399), hmsm(3, 5, 6, 900)); // overwrap
+        check!(hmsm(3, 5, 7, 900), Duration::seconds(-86399), hmsm(3, 5, 8, 900));
+        check!(hmsm(3, 5, 7, 900), Duration::days(12345), hmsm(3, 5, 7, 900));
+        check!(hmsm(3, 5, 7, 1_300), Duration::days(1), hmsm(3, 5, 7, 300));
+        check!(hmsm(3, 5, 7, 1_300), Duration::days(-1), hmsm(3, 5, 8, 300));
+
+        // regression tests for #37
+        check!(hmsm(0, 0, 0, 0), Duration::milliseconds(-990), hmsm(23, 59, 59, 10));
+        check!(hmsm(0, 0, 0, 0), Duration::milliseconds(-9990), hmsm(23, 59, 50, 10));
+    }
+
+    #[test]
+    fn test_time_overflowing_add() {
+        let hmsm = NaiveTime::from_hms_milli;
+
+        assert_eq!(
+            hmsm(3, 4, 5, 678).overflowing_add_signed(Duration::hours(11)),
+            (hmsm(14, 4, 5, 678), 0)
+        );
+        assert_eq!(
+            hmsm(3, 4, 5, 678).overflowing_add_signed(Duration::hours(23)),
+            (hmsm(2, 4, 5, 678), 86_400)
+        );
+        assert_eq!(
+            hmsm(3, 4, 5, 678).overflowing_add_signed(Duration::hours(-7)),
+            (hmsm(20, 4, 5, 678), -86_400)
+        );
+
+        // overflowing_add_signed with leap seconds may be counter-intuitive
+        assert_eq!(
+            hmsm(3, 4, 5, 1_678).overflowing_add_signed(Duration::days(1)),
+            (hmsm(3, 4, 5, 678), 86_400)
+        );
+        assert_eq!(
+            hmsm(3, 4, 5, 1_678).overflowing_add_signed(Duration::days(-1)),
+            (hmsm(3, 4, 6, 678), -86_400)
+        );
+    }
+
+    #[test]
+    fn test_time_addassignment() {
+        let hms = NaiveTime::from_hms;
+        let mut time = hms(12, 12, 12);
+        time += Duration::hours(10);
+        assert_eq!(time, hms(22, 12, 12));
+        time += Duration::hours(10);
+        assert_eq!(time, hms(8, 12, 12));
+    }
+
+    #[test]
+    fn test_time_subassignment() {
+        let hms = NaiveTime::from_hms;
+        let mut time = hms(12, 12, 12);
+        time -= Duration::hours(10);
+        assert_eq!(time, hms(2, 12, 12));
+        time -= Duration::hours(10);
+        assert_eq!(time, hms(16, 12, 12));
+    }
+
+    #[test]
+    fn test_time_sub() {
+        macro_rules! check {
+            ($lhs:expr, $rhs:expr, $diff:expr) => {{
+                // `time1 - time2 = duration` is equivalent to `time2 - time1 = -duration`
+                assert_eq!($lhs.signed_duration_since($rhs), $diff);
+                assert_eq!($rhs.signed_duration_since($lhs), -$diff);
+            }};
+        }
+
+        let hmsm = |h, m, s, mi| NaiveTime::from_hms_milli(h, m, s, mi);
+
+        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));
+        check!(hmsm(3, 5, 7, 200), hmsm(2, 4, 6, 200), Duration::seconds(3600 + 60 + 1));
+        check!(
+            hmsm(3, 5, 7, 200),
+            hmsm(2, 4, 6, 300),
+            Duration::seconds(3600 + 60) + Duration::milliseconds(900)
+        );
+
+        // treats the leap second as if it coincides with the prior non-leap second,
+        // as required by `time1 - time2 = duration` and `time2 - time1 = -duration` equivalence.
+        check!(hmsm(3, 5, 7, 200), hmsm(3, 5, 6, 1_800), Duration::milliseconds(400));
+        check!(hmsm(3, 5, 7, 1_200), hmsm(3, 5, 6, 1_800), Duration::milliseconds(1400));
+        check!(hmsm(3, 5, 7, 1_200), hmsm(3, 5, 6, 800), Duration::milliseconds(1400));
+
+        // additional equality: `time1 + duration = time2` is equivalent to
+        // `time2 - time1 = duration` IF AND ONLY IF `time2` represents a non-leap second.
+        assert_eq!(hmsm(3, 5, 6, 800) + Duration::milliseconds(400), hmsm(3, 5, 7, 200));
+        assert_eq!(hmsm(3, 5, 6, 1_800) + Duration::milliseconds(400), hmsm(3, 5, 7, 200));
+    }
+
+    #[test]
+    fn test_time_fmt() {
+        assert_eq!(format!("{}", NaiveTime::from_hms_milli(23, 59, 59, 999)), "23:59:59.999");
+        assert_eq!(format!("{}", NaiveTime::from_hms_milli(23, 59, 59, 1_000)), "23:59:60");
+        assert_eq!(format!("{}", NaiveTime::from_hms_milli(23, 59, 59, 1_001)), "23:59:60.001");
+        assert_eq!(format!("{}", NaiveTime::from_hms_micro(0, 0, 0, 43210)), "00:00:00.043210");
+        assert_eq!(format!("{}", NaiveTime::from_hms_nano(0, 0, 0, 6543210)), "00:00:00.006543210");
+
+        // the format specifier should have no effect on `NaiveTime`
+        assert_eq!(format!("{:30}", NaiveTime::from_hms_milli(3, 5, 7, 9)), "03:05:07.009");
+    }
+
+    #[test]
+    fn test_date_from_str() {
+        // valid cases
+        let valid = [
+            "0:0:0",
+            "0:0:0.0000000",
+            "0:0:0.0000003",
+            " 4 : 3 : 2.1 ",
+            " 09:08:07 ",
+            " 9:8:07 ",
+            "23:59:60.373929310237",
+        ];
+        for &s in &valid {
+            let d = match s.parse::<NaiveTime>() {
+                Ok(d) => d,
+                Err(e) => panic!("parsing `{}` has failed: {}", s, e),
+            };
+            let s_ = format!("{:?}", d);
+            // `s` and `s_` may differ, but `s.parse()` and `s_.parse()` must be same
+            let d_ = match s_.parse::<NaiveTime>() {
+                Ok(d) => d,
+                Err(e) => {
+                    panic!("`{}` is parsed into `{:?}`, but reparsing that has failed: {}", s, d, e)
+                }
+            };
+            assert!(
+                d == d_,
+                "`{}` is parsed into `{:?}`, but reparsed result \
+                              `{:?}` does not match",
+                s,
+                d,
+                d_
+            );
+        }
+
+        // some invalid cases
+        // since `ParseErrorKind` is private, all we can do is to check if there was an error
+        assert!("".parse::<NaiveTime>().is_err());
+        assert!("x".parse::<NaiveTime>().is_err());
+        assert!("15".parse::<NaiveTime>().is_err());
+        assert!("15:8".parse::<NaiveTime>().is_err());
+        assert!("15:8:x".parse::<NaiveTime>().is_err());
+        assert!("15:8:9x".parse::<NaiveTime>().is_err());
+        assert!("23:59:61".parse::<NaiveTime>().is_err());
+        assert!("12:34:56.x".parse::<NaiveTime>().is_err());
+        assert!("12:34:56. 0".parse::<NaiveTime>().is_err());
+    }
+
+    #[test]
+    fn test_time_parse_from_str() {
+        let hms = |h, m, s| NaiveTime::from_hms(h, m, s);
+        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))
+        ); // ignore date and offset
+        assert_eq!(NaiveTime::parse_from_str("PM 12:59", "%P %H:%M"), Ok(hms(12, 59, 0)));
+        assert!(NaiveTime::parse_from_str("12:3456", "%H:%M:%S").is_err());
+    }
+
+    #[test]
+    fn test_time_format() {
+        let t = NaiveTime::from_hms_nano(3, 5, 7, 98765432);
+        assert_eq!(t.format("%H,%k,%I,%l,%P,%p").to_string(), "03, 3,03, 3,am,AM");
+        assert_eq!(t.format("%M").to_string(), "05");
+        assert_eq!(t.format("%S,%f,%.f").to_string(), "07,098765432,.098765432");
+        assert_eq!(t.format("%.3f,%.6f,%.9f").to_string(), ".098,.098765,.098765432");
+        assert_eq!(t.format("%R").to_string(), "03:05");
+        assert_eq!(t.format("%T,%X").to_string(), "03:05:07,03:05:07");
+        assert_eq!(t.format("%r").to_string(), "03:05:07 AM");
+        assert_eq!(t.format("%t%n%%%n%t").to_string(), "\t\n%\n\t");
+
+        let t = NaiveTime::from_hms_micro(3, 5, 7, 432100);
+        assert_eq!(t.format("%S,%f,%.f").to_string(), "07,432100000,.432100");
+        assert_eq!(t.format("%.3f,%.6f,%.9f").to_string(), ".432,.432100,.432100000");
+
+        let t = NaiveTime::from_hms_milli(3, 5, 7, 210);
+        assert_eq!(t.format("%S,%f,%.f").to_string(), "07,210000000,.210");
+        assert_eq!(t.format("%.3f,%.6f,%.9f").to_string(), ".210,.210000,.210000000");
+
+        let t = NaiveTime::from_hms(3, 5, 7);
+        assert_eq!(t.format("%S,%f,%.f").to_string(), "07,000000000,");
+        assert_eq!(t.format("%.3f,%.6f,%.9f").to_string(), ".000,.000000,.000000000");
+
+        // corner cases
+        assert_eq!(NaiveTime::from_hms(13, 57, 9).format("%r").to_string(), "01:57:09 PM");
+        assert_eq!(
+            NaiveTime::from_hms_milli(23, 59, 59, 1_000).format("%X").to_string(),
+            "23:59:60"
+        );
+    }
+}