chrono/
date.rs

1// This is a part of Chrono.
2// See README.md and LICENSE.txt for details.
3
4//! ISO 8601 calendar date with time zone.
5#![allow(deprecated)]
6
7#[cfg(feature = "alloc")]
8use core::borrow::Borrow;
9use core::cmp::Ordering;
10use core::ops::{Add, AddAssign, Sub, SubAssign};
11use core::{fmt, hash};
12
13#[cfg(feature = "rkyv")]
14use rkyv::{Archive, Deserialize, Serialize};
15
16#[cfg(all(feature = "unstable-locales", feature = "alloc"))]
17use crate::format::Locale;
18#[cfg(feature = "alloc")]
19use crate::format::{DelayedFormat, Item, StrftimeItems};
20use crate::naive::{IsoWeek, NaiveDate, NaiveTime};
21use crate::offset::{TimeZone, Utc};
22use crate::{DateTime, Datelike, TimeDelta, Weekday};
23
24/// ISO 8601 calendar date with time zone.
25///
26/// You almost certainly want to be using a [`NaiveDate`] instead of this type.
27///
28/// This type primarily exists to aid in the construction of DateTimes that
29/// have a timezone by way of the [`TimeZone`] datelike constructors (e.g.
30/// [`TimeZone::ymd`]).
31///
32/// This type should be considered ambiguous at best, due to the inherent lack
33/// of precision required for the time zone resolution.
34///
35/// There are some guarantees on the usage of `Date<Tz>`:
36///
37/// - If properly constructed via [`TimeZone::ymd`] and others without an error,
38///   the corresponding local date should exist for at least a moment.
39///   (It may still have a gap from the offset changes.)
40///
41/// - The `TimeZone` is free to assign *any* [`Offset`](crate::offset::Offset) to the
42///   local date, as long as that offset did occur in given day.
43///
44///   For example, if `2015-03-08T01:59-08:00` is followed by `2015-03-08T03:00-07:00`,
45///   it may produce either `2015-03-08-08:00` or `2015-03-08-07:00`
46///   but *not* `2015-03-08+00:00` and others.
47///
48/// - Once constructed as a full `DateTime`, [`DateTime::date`] and other associated
49///   methods should return those for the original `Date`. For example, if `dt =
50///   tz.ymd_opt(y,m,d).unwrap().hms(h,n,s)` were valid, `dt.date() == tz.ymd_opt(y,m,d).unwrap()`.
51///
52/// - The date is timezone-agnostic up to one day (i.e. practically always),
53///   so the local date and UTC date should be equal for most cases
54///   even though the raw calculation between `NaiveDate` and `TimeDelta` may not.
55#[deprecated(since = "0.4.23", note = "Use `NaiveDate` or `DateTime<Tz>` instead")]
56#[derive(Clone)]
57#[cfg_attr(feature = "rkyv", derive(Archive, Deserialize, Serialize))]
58pub struct Date<Tz: TimeZone> {
59    date: NaiveDate,
60    offset: Tz::Offset,
61}
62
63/// The minimum possible `Date`.
64#[allow(deprecated)]
65#[deprecated(since = "0.4.20", note = "Use Date::MIN_UTC instead")]
66pub const MIN_DATE: Date<Utc> = Date::<Utc>::MIN_UTC;
67/// The maximum possible `Date`.
68#[allow(deprecated)]
69#[deprecated(since = "0.4.20", note = "Use Date::MAX_UTC instead")]
70pub const MAX_DATE: Date<Utc> = Date::<Utc>::MAX_UTC;
71
72impl<Tz: TimeZone> Date<Tz> {
73    /// Makes a new `Date` with given *UTC* date and offset.
74    /// The local date should be constructed via the `TimeZone` trait.
75    #[inline]
76    #[must_use]
77    pub fn from_utc(date: NaiveDate, offset: Tz::Offset) -> Date<Tz> {
78        Date { date, offset }
79    }
80
81    /// Makes a new `DateTime` from the current date and given `NaiveTime`.
82    /// The offset in the current date is preserved.
83    ///
84    /// Returns `None` on invalid datetime.
85    #[inline]
86    #[must_use]
87    pub fn and_time(&self, time: NaiveTime) -> Option<DateTime<Tz>> {
88        let localdt = self.naive_local().and_time(time);
89        self.timezone().from_local_datetime(&localdt).single()
90    }
91
92    /// Makes a new `DateTime` from the current date, hour, minute and second.
93    /// The offset in the current date is preserved.
94    ///
95    /// Panics on invalid hour, minute and/or second.
96    #[deprecated(since = "0.4.23", note = "Use and_hms_opt() instead")]
97    #[inline]
98    #[must_use]
99    pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> DateTime<Tz> {
100        self.and_hms_opt(hour, min, sec).expect("invalid time")
101    }
102
103    /// Makes a new `DateTime` from the current date, hour, minute and second.
104    /// The offset in the current date is preserved.
105    ///
106    /// Returns `None` on invalid hour, minute and/or second.
107    #[inline]
108    #[must_use]
109    pub fn and_hms_opt(&self, hour: u32, min: u32, sec: u32) -> Option<DateTime<Tz>> {
110        NaiveTime::from_hms_opt(hour, min, sec).and_then(|time| self.and_time(time))
111    }
112
113    /// Makes a new `DateTime` from the current date, hour, minute, second and millisecond.
114    /// The millisecond part can exceed 1,000 in order to represent the leap second.
115    /// The offset in the current date is preserved.
116    ///
117    /// Panics on invalid hour, minute, second and/or millisecond.
118    #[deprecated(since = "0.4.23", note = "Use and_hms_milli_opt() instead")]
119    #[inline]
120    #[must_use]
121    pub fn and_hms_milli(&self, hour: u32, min: u32, sec: u32, milli: u32) -> DateTime<Tz> {
122        self.and_hms_milli_opt(hour, min, sec, milli).expect("invalid time")
123    }
124
125    /// Makes a new `DateTime` from the current date, hour, minute, second and millisecond.
126    /// The millisecond part can exceed 1,000 in order to represent the leap second.
127    /// The offset in the current date is preserved.
128    ///
129    /// Returns `None` on invalid hour, minute, second and/or millisecond.
130    #[inline]
131    #[must_use]
132    pub fn and_hms_milli_opt(
133        &self,
134        hour: u32,
135        min: u32,
136        sec: u32,
137        milli: u32,
138    ) -> Option<DateTime<Tz>> {
139        NaiveTime::from_hms_milli_opt(hour, min, sec, milli).and_then(|time| self.and_time(time))
140    }
141
142    /// Makes a new `DateTime` from the current date, hour, minute, second and microsecond.
143    /// The microsecond part can exceed 1,000,000 in order to represent the leap second.
144    /// The offset in the current date is preserved.
145    ///
146    /// Panics on invalid hour, minute, second and/or microsecond.
147    #[deprecated(since = "0.4.23", note = "Use and_hms_micro_opt() instead")]
148    #[inline]
149    #[must_use]
150    pub fn and_hms_micro(&self, hour: u32, min: u32, sec: u32, micro: u32) -> DateTime<Tz> {
151        self.and_hms_micro_opt(hour, min, sec, micro).expect("invalid time")
152    }
153
154    /// Makes a new `DateTime` from the current date, hour, minute, second and microsecond.
155    /// The microsecond part can exceed 1,000,000 in order to represent the leap second.
156    /// The offset in the current date is preserved.
157    ///
158    /// Returns `None` on invalid hour, minute, second and/or microsecond.
159    #[inline]
160    #[must_use]
161    pub fn and_hms_micro_opt(
162        &self,
163        hour: u32,
164        min: u32,
165        sec: u32,
166        micro: u32,
167    ) -> Option<DateTime<Tz>> {
168        NaiveTime::from_hms_micro_opt(hour, min, sec, micro).and_then(|time| self.and_time(time))
169    }
170
171    /// Makes a new `DateTime` from the current date, hour, minute, second and nanosecond.
172    /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
173    /// The offset in the current date is preserved.
174    ///
175    /// Panics on invalid hour, minute, second and/or nanosecond.
176    #[deprecated(since = "0.4.23", note = "Use and_hms_nano_opt() instead")]
177    #[inline]
178    #[must_use]
179    pub fn and_hms_nano(&self, hour: u32, min: u32, sec: u32, nano: u32) -> DateTime<Tz> {
180        self.and_hms_nano_opt(hour, min, sec, nano).expect("invalid time")
181    }
182
183    /// Makes a new `DateTime` from the current date, hour, minute, second and nanosecond.
184    /// The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.
185    /// The offset in the current date is preserved.
186    ///
187    /// Returns `None` on invalid hour, minute, second and/or nanosecond.
188    #[inline]
189    #[must_use]
190    pub fn and_hms_nano_opt(
191        &self,
192        hour: u32,
193        min: u32,
194        sec: u32,
195        nano: u32,
196    ) -> Option<DateTime<Tz>> {
197        NaiveTime::from_hms_nano_opt(hour, min, sec, nano).and_then(|time| self.and_time(time))
198    }
199
200    /// Makes a new `Date` for the next date.
201    ///
202    /// Panics when `self` is the last representable date.
203    #[deprecated(since = "0.4.23", note = "Use succ_opt() instead")]
204    #[inline]
205    #[must_use]
206    pub fn succ(&self) -> Date<Tz> {
207        self.succ_opt().expect("out of bound")
208    }
209
210    /// Makes a new `Date` for the next date.
211    ///
212    /// Returns `None` when `self` is the last representable date.
213    #[inline]
214    #[must_use]
215    pub fn succ_opt(&self) -> Option<Date<Tz>> {
216        self.date.succ_opt().map(|date| Date::from_utc(date, self.offset.clone()))
217    }
218
219    /// Makes a new `Date` for the prior date.
220    ///
221    /// Panics when `self` is the first representable date.
222    #[deprecated(since = "0.4.23", note = "Use pred_opt() instead")]
223    #[inline]
224    #[must_use]
225    pub fn pred(&self) -> Date<Tz> {
226        self.pred_opt().expect("out of bound")
227    }
228
229    /// Makes a new `Date` for the prior date.
230    ///
231    /// Returns `None` when `self` is the first representable date.
232    #[inline]
233    #[must_use]
234    pub fn pred_opt(&self) -> Option<Date<Tz>> {
235        self.date.pred_opt().map(|date| Date::from_utc(date, self.offset.clone()))
236    }
237
238    /// Retrieves an associated offset from UTC.
239    #[inline]
240    #[must_use]
241    pub fn offset(&self) -> &Tz::Offset {
242        &self.offset
243    }
244
245    /// Retrieves an associated time zone.
246    #[inline]
247    #[must_use]
248    pub fn timezone(&self) -> Tz {
249        TimeZone::from_offset(&self.offset)
250    }
251
252    /// Changes the associated time zone.
253    /// This does not change the actual `Date` (but will change the string representation).
254    #[inline]
255    #[must_use]
256    pub fn with_timezone<Tz2: TimeZone>(&self, tz: &Tz2) -> Date<Tz2> {
257        tz.from_utc_date(&self.date)
258    }
259
260    /// Adds given `TimeDelta` to the current date.
261    ///
262    /// Returns `None` when it will result in overflow.
263    #[inline]
264    #[must_use]
265    pub fn checked_add_signed(self, rhs: TimeDelta) -> Option<Date<Tz>> {
266        let date = self.date.checked_add_signed(rhs)?;
267        Some(Date { date, offset: self.offset })
268    }
269
270    /// Subtracts given `TimeDelta` from the current date.
271    ///
272    /// Returns `None` when it will result in overflow.
273    #[inline]
274    #[must_use]
275    pub fn checked_sub_signed(self, rhs: TimeDelta) -> Option<Date<Tz>> {
276        let date = self.date.checked_sub_signed(rhs)?;
277        Some(Date { date, offset: self.offset })
278    }
279
280    /// Subtracts another `Date` from the current date.
281    /// Returns a `TimeDelta` of integral numbers.
282    ///
283    /// This does not overflow or underflow at all,
284    /// as all possible output fits in the range of `TimeDelta`.
285    #[inline]
286    #[must_use]
287    pub fn signed_duration_since<Tz2: TimeZone>(self, rhs: Date<Tz2>) -> TimeDelta {
288        self.date.signed_duration_since(rhs.date)
289    }
290
291    /// Returns a view to the naive UTC date.
292    #[inline]
293    #[must_use]
294    pub fn naive_utc(&self) -> NaiveDate {
295        self.date
296    }
297
298    /// Returns a view to the naive local date.
299    ///
300    /// This is technically the same as [`naive_utc`](#method.naive_utc)
301    /// because the offset is restricted to never exceed one day,
302    /// but provided for the consistency.
303    #[inline]
304    #[must_use]
305    pub fn naive_local(&self) -> NaiveDate {
306        self.date
307    }
308
309    /// Returns the number of whole years from the given `base` until `self`.
310    #[must_use]
311    pub fn years_since(&self, base: Self) -> Option<u32> {
312        self.date.years_since(base.date)
313    }
314
315    /// The minimum possible `Date`.
316    pub const MIN_UTC: Date<Utc> = Date { date: NaiveDate::MIN, offset: Utc };
317    /// The maximum possible `Date`.
318    pub const MAX_UTC: Date<Utc> = Date { date: NaiveDate::MAX, offset: Utc };
319}
320
321/// Maps the local date to other date with given conversion function.
322fn map_local<Tz: TimeZone, F>(d: &Date<Tz>, mut f: F) -> Option<Date<Tz>>
323where
324    F: FnMut(NaiveDate) -> Option<NaiveDate>,
325{
326    f(d.naive_local()).and_then(|date| d.timezone().from_local_date(&date).single())
327}
328
329impl<Tz: TimeZone> Date<Tz>
330where
331    Tz::Offset: fmt::Display,
332{
333    /// Formats the date with the specified formatting items.
334    #[cfg(feature = "alloc")]
335    #[inline]
336    #[must_use]
337    pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
338    where
339        I: Iterator<Item = B> + Clone,
340        B: Borrow<Item<'a>>,
341    {
342        DelayedFormat::new_with_offset(Some(self.naive_local()), None, &self.offset, items)
343    }
344
345    /// Formats the date with the specified format string.
346    /// See the [`crate::format::strftime`] module
347    /// on the supported escape sequences.
348    #[cfg(feature = "alloc")]
349    #[inline]
350    #[must_use]
351    pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>> {
352        self.format_with_items(StrftimeItems::new(fmt))
353    }
354
355    /// Formats the date with the specified formatting items and locale.
356    #[cfg(all(feature = "unstable-locales", feature = "alloc"))]
357    #[inline]
358    #[must_use]
359    pub fn format_localized_with_items<'a, I, B>(
360        &self,
361        items: I,
362        locale: Locale,
363    ) -> DelayedFormat<I>
364    where
365        I: Iterator<Item = B> + Clone,
366        B: Borrow<Item<'a>>,
367    {
368        DelayedFormat::new_with_offset_and_locale(
369            Some(self.naive_local()),
370            None,
371            &self.offset,
372            items,
373            locale,
374        )
375    }
376
377    /// Formats the date with the specified format string and locale.
378    /// See the [`crate::format::strftime`] module
379    /// on the supported escape sequences.
380    #[cfg(all(feature = "unstable-locales", feature = "alloc"))]
381    #[inline]
382    #[must_use]
383    pub fn format_localized<'a>(
384        &self,
385        fmt: &'a str,
386        locale: Locale,
387    ) -> DelayedFormat<StrftimeItems<'a>> {
388        self.format_localized_with_items(StrftimeItems::new_with_locale(fmt, locale), locale)
389    }
390}
391
392impl<Tz: TimeZone> Datelike for Date<Tz> {
393    #[inline]
394    fn year(&self) -> i32 {
395        self.naive_local().year()
396    }
397    #[inline]
398    fn month(&self) -> u32 {
399        self.naive_local().month()
400    }
401    #[inline]
402    fn month0(&self) -> u32 {
403        self.naive_local().month0()
404    }
405    #[inline]
406    fn day(&self) -> u32 {
407        self.naive_local().day()
408    }
409    #[inline]
410    fn day0(&self) -> u32 {
411        self.naive_local().day0()
412    }
413    #[inline]
414    fn ordinal(&self) -> u32 {
415        self.naive_local().ordinal()
416    }
417    #[inline]
418    fn ordinal0(&self) -> u32 {
419        self.naive_local().ordinal0()
420    }
421    #[inline]
422    fn weekday(&self) -> Weekday {
423        self.naive_local().weekday()
424    }
425    #[inline]
426    fn iso_week(&self) -> IsoWeek {
427        self.naive_local().iso_week()
428    }
429
430    #[inline]
431    fn with_year(&self, year: i32) -> Option<Date<Tz>> {
432        map_local(self, |date| date.with_year(year))
433    }
434
435    #[inline]
436    fn with_month(&self, month: u32) -> Option<Date<Tz>> {
437        map_local(self, |date| date.with_month(month))
438    }
439
440    #[inline]
441    fn with_month0(&self, month0: u32) -> Option<Date<Tz>> {
442        map_local(self, |date| date.with_month0(month0))
443    }
444
445    #[inline]
446    fn with_day(&self, day: u32) -> Option<Date<Tz>> {
447        map_local(self, |date| date.with_day(day))
448    }
449
450    #[inline]
451    fn with_day0(&self, day0: u32) -> Option<Date<Tz>> {
452        map_local(self, |date| date.with_day0(day0))
453    }
454
455    #[inline]
456    fn with_ordinal(&self, ordinal: u32) -> Option<Date<Tz>> {
457        map_local(self, |date| date.with_ordinal(ordinal))
458    }
459
460    #[inline]
461    fn with_ordinal0(&self, ordinal0: u32) -> Option<Date<Tz>> {
462        map_local(self, |date| date.with_ordinal0(ordinal0))
463    }
464}
465
466// we need them as automatic impls cannot handle associated types
467impl<Tz: TimeZone> Copy for Date<Tz> where <Tz as TimeZone>::Offset: Copy {}
468unsafe impl<Tz: TimeZone> Send for Date<Tz> where <Tz as TimeZone>::Offset: Send {}
469
470impl<Tz: TimeZone, Tz2: TimeZone> PartialEq<Date<Tz2>> for Date<Tz> {
471    fn eq(&self, other: &Date<Tz2>) -> bool {
472        self.date == other.date
473    }
474}
475
476impl<Tz: TimeZone> Eq for Date<Tz> {}
477
478impl<Tz: TimeZone> PartialOrd for Date<Tz> {
479    fn partial_cmp(&self, other: &Date<Tz>) -> Option<Ordering> {
480        Some(self.cmp(other))
481    }
482}
483
484impl<Tz: TimeZone> Ord for Date<Tz> {
485    fn cmp(&self, other: &Date<Tz>) -> Ordering {
486        self.date.cmp(&other.date)
487    }
488}
489
490impl<Tz: TimeZone> hash::Hash for Date<Tz> {
491    fn hash<H: hash::Hasher>(&self, state: &mut H) {
492        self.date.hash(state)
493    }
494}
495
496impl<Tz: TimeZone> Add<TimeDelta> for Date<Tz> {
497    type Output = Date<Tz>;
498
499    #[inline]
500    fn add(self, rhs: TimeDelta) -> Date<Tz> {
501        self.checked_add_signed(rhs).expect("`Date + TimeDelta` overflowed")
502    }
503}
504
505impl<Tz: TimeZone> AddAssign<TimeDelta> for Date<Tz> {
506    #[inline]
507    fn add_assign(&mut self, rhs: TimeDelta) {
508        self.date = self.date.checked_add_signed(rhs).expect("`Date + TimeDelta` overflowed");
509    }
510}
511
512impl<Tz: TimeZone> Sub<TimeDelta> for Date<Tz> {
513    type Output = Date<Tz>;
514
515    #[inline]
516    fn sub(self, rhs: TimeDelta) -> Date<Tz> {
517        self.checked_sub_signed(rhs).expect("`Date - TimeDelta` overflowed")
518    }
519}
520
521impl<Tz: TimeZone> SubAssign<TimeDelta> for Date<Tz> {
522    #[inline]
523    fn sub_assign(&mut self, rhs: TimeDelta) {
524        self.date = self.date.checked_sub_signed(rhs).expect("`Date - TimeDelta` overflowed");
525    }
526}
527
528impl<Tz: TimeZone> Sub<Date<Tz>> for Date<Tz> {
529    type Output = TimeDelta;
530
531    #[inline]
532    fn sub(self, rhs: Date<Tz>) -> TimeDelta {
533        self.signed_duration_since(rhs)
534    }
535}
536
537impl<Tz: TimeZone> fmt::Debug for Date<Tz> {
538    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
539        self.naive_local().fmt(f)?;
540        self.offset.fmt(f)
541    }
542}
543
544impl<Tz: TimeZone> fmt::Display for Date<Tz>
545where
546    Tz::Offset: fmt::Display,
547{
548    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
549        self.naive_local().fmt(f)?;
550        self.offset.fmt(f)
551    }
552}
553
554// Note that implementation of Arbitrary cannot be automatically derived for Date<Tz>, due to
555// the nontrivial bound <Tz as TimeZone>::Offset: Arbitrary.
556#[cfg(all(feature = "arbitrary", feature = "std"))]
557impl<'a, Tz> arbitrary::Arbitrary<'a> for Date<Tz>
558where
559    Tz: TimeZone,
560    <Tz as TimeZone>::Offset: arbitrary::Arbitrary<'a>,
561{
562    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Date<Tz>> {
563        let date = NaiveDate::arbitrary(u)?;
564        let offset = <Tz as TimeZone>::Offset::arbitrary(u)?;
565        Ok(Date::from_utc(date, offset))
566    }
567}
568
569#[cfg(test)]
570mod tests {
571    use super::Date;
572
573    use crate::{FixedOffset, NaiveDate, TimeDelta, Utc};
574
575    #[cfg(feature = "clock")]
576    use crate::offset::{Local, TimeZone};
577
578    #[test]
579    #[cfg(feature = "clock")]
580    fn test_years_elapsed() {
581        const WEEKS_PER_YEAR: f32 = 52.1775;
582
583        // This is always at least one year because 1 year = 52.1775 weeks.
584        let one_year_ago = Utc::today() - TimeDelta::weeks((WEEKS_PER_YEAR * 1.5).ceil() as i64);
585        // A bit more than 2 years.
586        let two_year_ago = Utc::today() - TimeDelta::weeks((WEEKS_PER_YEAR * 2.5).ceil() as i64);
587
588        assert_eq!(Utc::today().years_since(one_year_ago), Some(1));
589        assert_eq!(Utc::today().years_since(two_year_ago), Some(2));
590
591        // If the given DateTime is later than now, the function will always return 0.
592        let future = Utc::today() + TimeDelta::weeks(12);
593        assert_eq!(Utc::today().years_since(future), None);
594    }
595
596    #[test]
597    fn test_date_add_assign() {
598        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
599        let date = Date::<Utc>::from_utc(naivedate, Utc);
600        let mut date_add = date;
601
602        date_add += TimeDelta::days(5);
603        assert_eq!(date_add, date + TimeDelta::days(5));
604
605        let timezone = FixedOffset::east_opt(60 * 60).unwrap();
606        let date = date.with_timezone(&timezone);
607        let date_add = date_add.with_timezone(&timezone);
608
609        assert_eq!(date_add, date + TimeDelta::days(5));
610
611        let timezone = FixedOffset::west_opt(2 * 60 * 60).unwrap();
612        let date = date.with_timezone(&timezone);
613        let date_add = date_add.with_timezone(&timezone);
614
615        assert_eq!(date_add, date + TimeDelta::days(5));
616    }
617
618    #[test]
619    #[cfg(feature = "clock")]
620    fn test_date_add_assign_local() {
621        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
622
623        let date = Local.from_utc_date(&naivedate);
624        let mut date_add = date;
625
626        date_add += TimeDelta::days(5);
627        assert_eq!(date_add, date + TimeDelta::days(5));
628    }
629
630    #[test]
631    fn test_date_sub_assign() {
632        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
633        let date = Date::<Utc>::from_utc(naivedate, Utc);
634        let mut date_sub = date;
635
636        date_sub -= TimeDelta::days(5);
637        assert_eq!(date_sub, date - TimeDelta::days(5));
638
639        let timezone = FixedOffset::east_opt(60 * 60).unwrap();
640        let date = date.with_timezone(&timezone);
641        let date_sub = date_sub.with_timezone(&timezone);
642
643        assert_eq!(date_sub, date - TimeDelta::days(5));
644
645        let timezone = FixedOffset::west_opt(2 * 60 * 60).unwrap();
646        let date = date.with_timezone(&timezone);
647        let date_sub = date_sub.with_timezone(&timezone);
648
649        assert_eq!(date_sub, date - TimeDelta::days(5));
650    }
651
652    #[test]
653    #[cfg(feature = "clock")]
654    fn test_date_sub_assign_local() {
655        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
656
657        let date = Local.from_utc_date(&naivedate);
658        let mut date_sub = date;
659
660        date_sub -= TimeDelta::days(5);
661        assert_eq!(date_sub, date - TimeDelta::days(5));
662    }
663}
chrono/date.rs

chrono/
date.rs
