parse_net/date/
mail_date.rs

1//! RFC 5322 section 3.3 `date-time`, with the obsolete forms of section 4.3
2//! on request.
3
4use super::{
5    DAY_NAMES, MAX_SECS, MIN_SECS, MONTH_NAMES, SECS_PER_DAY, civil_from_days, days_from_civil,
6    days_in_month, weekday_from_days,
7};
8use crate::{
9    error::{ErrorKind, ParseError, Result, WriteError, err},
10    limits::Limits,
11    scan::control_kind,
12    text::comment_end,
13    write::{Sink, reserve},
14};
15
16/// The largest zone offset, `+9959`, in minutes.
17const MAX_OFFSET: i16 = 99 * 60 + 59;
18
19/// A point in time with a zone offset, from an email `Date` or `Received`
20/// field (RFC 5322 section 3.3).
21///
22/// # Examples
23///
24/// ```
25/// use parse_net::MailDate;
26///
27/// let d = MailDate::parse(b"Wed, 21 Oct 2026 17:38:00 +0200", false)?;
28/// assert_eq!(d.offset_minutes(), 120);
29/// let mut buf = [0u8; 64];
30/// let mut out = parse_net::SliceSink::new(&mut buf);
31/// d.write_to(&mut out).expect("room");
32/// assert_eq!(out.written(), b"Wed, 21 Oct 2026 17:38:00 +0200");
33/// assert!(MailDate::parse(b"21 Oct 26 17:38 EDT", false).is_err());
34/// assert_eq!(MailDate::parse(b"21 Oct 26 17:38 EDT", true)?.offset_minutes(), -240);
35/// # Ok::<(), parse_net::ParseError>(())
36/// ```
37#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
38pub struct MailDate {
39    utc: i64,
40    offset: i16,
41    offset_unknown: bool,
42    leap_second: bool,
43}
44
45impl MailDate {
46    /// The time `utc_secs` (seconds since the Unix epoch) shown in the zone
47    /// `offset_minutes` east of UTC.
48    ///
49    /// # Errors
50    ///
51    /// [`ErrorKind::OutOfRange`] for an offset beyond plus or minus 99:59 or
52    /// a local time outside years 1 to 9999.
53    ///
54    /// # Examples
55    ///
56    /// ```
57    /// use parse_net::MailDate;
58    ///
59    /// let d = MailDate::new(0, -300)?;
60    /// assert_eq!(&d.format().0[..d.format().1], b"Wed, 31 Dec 1969 19:00:00 -0500");
61    /// assert!(MailDate::new(0, 6000).is_err());
62    /// # Ok::<(), parse_net::ParseError>(())
63    /// ```
64    pub fn new(utc_secs: i64, offset_minutes: i16) -> Result<Self> {
65        if offset_minutes.unsigned_abs() > MAX_OFFSET.unsigned_abs() {
66            return err(ErrorKind::OutOfRange, 0);
67        }
68        let local = utc_secs.saturating_add(i64::from(offset_minutes) * 60);
69        if !(MIN_SECS..=MAX_SECS).contains(&local) {
70            return err(ErrorKind::OutOfRange, 0);
71        }
72        Ok(Self {
73            utc: utc_secs,
74            offset: offset_minutes,
75            offset_unknown: false,
76            leap_second: false,
77        })
78    }
79
80    /// Seconds since the Unix epoch, UTC.
81    ///
82    /// # Examples
83    ///
84    /// ```
85    /// let d = parse_net::MailDate::parse(b"1 Jan 1970 01:00:00 +0100", false)?;
86    /// assert_eq!(d.utc(), 0);
87    /// # Ok::<(), parse_net::ParseError>(())
88    /// ```
89    #[must_use]
90    pub const fn utc(self) -> i64 {
91        self.utc
92    }
93
94    /// The zone offset in minutes east of UTC (`0` when unknown).
95    ///
96    /// # Examples
97    ///
98    /// ```
99    /// let d = parse_net::MailDate::parse(b"21 Oct 2026 08:08:00 -0330", false)?;
100    /// assert_eq!(d.offset_minutes(), -210);
101    /// # Ok::<(), parse_net::ParseError>(())
102    /// ```
103    #[must_use]
104    pub const fn offset_minutes(self) -> i16 {
105        self.offset
106    }
107
108    /// Whether the zone was `-0000`: the time is UTC and the local zone is
109    /// unknown (RFC 5322 section 3.3), or an obsolete military zone, which
110    /// the RFC says to read the same way.
111    ///
112    /// # Examples
113    ///
114    /// ```
115    /// use parse_net::MailDate;
116    ///
117    /// assert!(MailDate::parse(b"21 Oct 2026 17:38:00 -0000", false)?.offset_unknown());
118    /// assert!(!MailDate::parse(b"21 Oct 2026 17:38:00 +0000", false)?.offset_unknown());
119    /// # Ok::<(), parse_net::ParseError>(())
120    /// ```
121    #[must_use]
122    pub const fn offset_unknown(self) -> bool {
123        self.offset_unknown
124    }
125
126    /// Whether the seconds were `60` (read as `59`).
127    ///
128    /// # Examples
129    ///
130    /// ```
131    /// use parse_net::MailDate;
132    ///
133    /// let leap = MailDate::parse(b"31 Dec 2016 23:59:60 +0000", false)?;
134    /// assert!(leap.leap_second());
135    /// assert_eq!(leap.utc(), MailDate::parse(b"31 Dec 2016 23:59:59 +0000", false)?.utc());
136    /// # Ok::<(), parse_net::ParseError>(())
137    /// ```
138    #[must_use]
139    pub const fn leap_second(self) -> bool {
140        self.leap_second
141    }
142
143    /// The value as `Wed, 21 Oct 2026 17:38:00 +0200`: weekday, two-digit
144    /// day, four-digit year, seconds, and a numeric zone (`-0000` when the
145    /// offset is unknown). Returns the bytes and their length (always 31).
146    ///
147    /// # Examples
148    ///
149    /// ```
150    /// let d = parse_net::MailDate::parse(b"21 oct 2026 17:38 +0200", false)?;
151    /// let (bytes, len) = d.format();
152    /// assert_eq!(&bytes[..len], b"Wed, 21 Oct 2026 17:38:00 +0200");
153    /// # Ok::<(), parse_net::ParseError>(())
154    /// ```
155    #[must_use]
156    pub fn format(self) -> ([u8; 31], usize) {
157        let local = self.utc + i64::from(self.offset) * 60;
158        let days = local.div_euclid(SECS_PER_DAY);
159        let secs = local.rem_euclid(SECS_PER_DAY);
160        let (year, month, day) = civil_from_days(days);
161        let mut out = [b' '; 31];
162        let wd = usize::from(weekday_from_days(days)).saturating_sub(1);
163        put(
164            &mut out,
165            0,
166            DAY_NAMES
167                .get(wd)
168                .map_or(b"???".as_slice(), |d| d.as_slice()),
169        );
170        put(&mut out, 3, b",");
171        two(&mut out, 5, day);
172        let mon = MONTH_NAMES
173            .get(usize::from(month).saturating_sub(1))
174            .map_or(b"???".as_slice(), |m| m.as_slice());
175        put(&mut out, 8, mon);
176        // Years 1 to 9999 by construction.
177        let y = u32::try_from(year).unwrap_or(0);
178        two(&mut out, 12, (y / 100) as u8);
179        two(&mut out, 14, (y % 100) as u8);
180        two(&mut out, 17, (secs / 3600) as u8);
181        put(&mut out, 19, b":");
182        two(&mut out, 20, (secs / 60 % 60) as u8);
183        put(&mut out, 22, b":");
184        two(&mut out, 23, (secs % 60) as u8);
185        let (sign, abs) = if self.offset < 0 || self.offset_unknown {
186            (b"-", self.offset.unsigned_abs())
187        } else {
188            (b"+", self.offset.unsigned_abs())
189        };
190        put(&mut out, 26, sign);
191        two(&mut out, 27, (abs / 60) as u8);
192        two(&mut out, 29, (abs % 60) as u8);
193        (out, 31)
194    }
195
196    /// Writes [`format`](Self::format)'s text.
197    ///
198    /// # Errors
199    ///
200    /// [`WriteError::Full`]; nothing is written when the sink reports its
201    /// room.
202    ///
203    /// # Examples
204    ///
205    /// ```
206    /// use parse_net::{MailDate, SliceSink, WriteError};
207    ///
208    /// let d = MailDate::new(0, 0).expect("in range");
209    /// let mut buf = [0u8; 40];
210    /// let mut out = SliceSink::new(&mut buf);
211    /// d.write_to(&mut out)?;
212    /// assert_eq!(out.written(), b"Thu, 01 Jan 1970 00:00:00 +0000");
213    /// assert_eq!(d.write_to(&mut SliceSink::new(&mut [0u8; 10])), Err(WriteError::Full));
214    /// # Ok::<(), parse_net::WriteError>(())
215    /// ```
216    pub fn write_to(self, out: &mut impl Sink) -> core::result::Result<(), WriteError> {
217        let (bytes, len) = self.format();
218        reserve(out, len)?;
219        out.put(bytes.get(..len).unwrap_or(&bytes))?;
220        Ok(())
221    }
222
223    /// Parses an RFC 5322 `date-time`. Names are case-insensitive (RFC 5234
224    /// quoted strings); comments and folding whitespace may separate the
225    /// tokens. With `obsolete`, also the section 4.3 forms: two- and
226    /// three-digit years (below 50 are 20xx, others 19xx; three digits add
227    /// 1900, D-036), `UT`, `GMT`, the North American zones, and the military
228    /// zones (read as `-0000`).
229    ///
230    /// # Errors
231    ///
232    /// [`ErrorKind::InvalidDate`] (a field out of range, a missing token, an
233    /// obsolete form without `obsolete`); [`ErrorKind::WeekdayMismatch`];
234    /// [`ErrorKind::OutOfRange`] (a year outside 1 to 9999);
235    /// [`ErrorKind::TrailingData`]; [`ErrorKind::UnbalancedComment`];
236    /// [`ErrorKind::CommentTooDeep`]; [`ErrorKind::BareCr`] and
237    /// [`ErrorKind::LineFeed`] for a line break that is not folding.
238    ///
239    /// # Examples
240    ///
241    /// ```
242    /// use parse_net::{ErrorKind, MailDate};
243    ///
244    /// let d = MailDate::parse(b"1 jan 2026 00:00 (morning) -0000", false)?;
245    /// assert!(d.offset_unknown());
246    /// assert_eq!(MailDate::parse(b"Mon, 21 Oct 2026 17:38:00 +0200", false).unwrap_err().kind(), ErrorKind::WeekdayMismatch);
247    /// # Ok::<(), parse_net::ParseError>(())
248    /// ```
249    pub fn parse(value: &[u8], obsolete: bool) -> Result<Self> {
250        let mut c = Cur {
251            v: value,
252            i: 0,
253            limits: Limits::DEFAULT,
254        };
255        let _ = c.cfws()?;
256        let weekday = if c.peek().is_some_and(|b| b.is_ascii_alphabetic()) {
257            let wd = c.name(&DAY_NAMES)?;
258            let _ = c.cfws()?;
259            if c.peek() != Some(b',') {
260                return Err(c.fail(ErrorKind::InvalidDate));
261            }
262            c.i += 1;
263            let _ = c.cfws()?;
264            Some(wd + 1)
265        } else {
266            None
267        };
268        let (day, n) = c.digits()?;
269        if !(1..=2).contains(&n) {
270            return Err(c.fail_at(ErrorKind::InvalidDate, c.i - n));
271        }
272        c.space()?;
273        let month = c.name(&MONTH_NAMES)? + 1;
274        c.space()?;
275        let at = c.i;
276        let (y, n) = c.digits()?;
277        let year = match n {
278            4.. => y,
279            2 if obsolete => {
280                if y < 50 {
281                    2000 + y
282                } else {
283                    1900 + y
284                }
285            }
286            3 if obsolete => 1900 + y,
287            _ => return Err(c.fail_at(ErrorKind::InvalidDate, at)),
288        };
289        if !(1..=9999).contains(&year) {
290            return err(ErrorKind::OutOfRange, at);
291        }
292        c.space()?;
293        let (hour, minute, second) = c.time(obsolete)?;
294        c.space()?;
295        let (offset, unknown) = c.zone(obsolete)?;
296        let _ = c.cfws()?;
297        if c.i < value.len() {
298            return Err(c.fail(ErrorKind::TrailingData));
299        }
300        let (year, month, day) = (year as i32, month as u8, day as u8);
301        if day == 0 || day > days_in_month(year, month) {
302            return err(ErrorKind::InvalidDate, 0);
303        }
304        let days = days_from_civil(year, month, day);
305        if weekday.is_some_and(|w| w as u8 != weekday_from_days(days)) {
306            return err(ErrorKind::WeekdayMismatch, 0);
307        }
308        let leap_second = second == 60;
309        let second = if leap_second { 59 } else { second };
310        let local = days * SECS_PER_DAY + hour * 3600 + minute * 60 + second;
311        Ok(Self {
312            utc: local - i64::from(offset) * 60,
313            offset,
314            offset_unknown: unknown,
315            leap_second,
316        })
317    }
318}
319
320fn put(out: &mut [u8], at: usize, bytes: &[u8]) {
321    if let Some(dst) = out.get_mut(at..at + bytes.len()) {
322        dst.copy_from_slice(bytes);
323    }
324}
325
326fn two(out: &mut [u8], at: usize, v: u8) {
327    put(out, at, &[b'0' + v / 10, b'0' + v % 10]);
328}
329
330/// A position in a `date-time`.
331struct Cur<'a> {
332    v: &'a [u8],
333    i: usize,
334    limits: Limits,
335}
336
337impl Cur<'_> {
338    fn peek(&self) -> Option<u8> {
339        self.v.get(self.i).copied()
340    }
341
342    fn fail_at(&self, kind: ErrorKind, at: usize) -> ParseError {
343        match self.v.get(at) {
344            Some(&b) if crate::scan::is_control(b) => ParseError::new(control_kind(b), at),
345            _ => ParseError::new(kind, at),
346        }
347    }
348
349    fn fail(&self, kind: ErrorKind) -> ParseError {
350        self.fail_at(kind, self.i)
351    }
352
353    /// Skips CFWS: WSP, `CRLF WSP`, and comments. Returns whether anything
354    /// was skipped.
355    fn cfws(&mut self) -> Result<bool> {
356        let start = self.i;
357        loop {
358            match self.peek() {
359                Some(b' ' | b'\t') => self.i += 1,
360                Some(b'\r') => {
361                    if self.v.get(self.i + 1) == Some(&b'\n')
362                        && matches!(self.v.get(self.i + 2), Some(b' ' | b'\t'))
363                    {
364                        self.i += 3;
365                    } else {
366                        return Err(self.fail(ErrorKind::BareCr));
367                    }
368                }
369                Some(b'(') => self.i = comment_end(self.v, self.i, &self.limits)?.0,
370                _ => return Ok(self.i > start),
371            }
372        }
373    }
374
375    /// CFWS that must be present (the grammar's `FWS`).
376    fn space(&mut self) -> Result<()> {
377        if self.cfws()? {
378            Ok(())
379        } else {
380            Err(self.fail(ErrorKind::InvalidDate))
381        }
382    }
383
384    /// A run of digits: its value (saturating) and length.
385    fn digits(&mut self) -> Result<(u32, usize)> {
386        let start = self.i;
387        let mut v: u32 = 0;
388        while let Some(d) = self.peek().filter(u8::is_ascii_digit) {
389            v = v.saturating_mul(10).saturating_add(u32::from(d - b'0'));
390            self.i += 1;
391        }
392        if self.i == start {
393            return Err(self.fail(ErrorKind::InvalidDate));
394        }
395        Ok((v, self.i - start))
396    }
397
398    /// Exactly two digits.
399    fn two(&mut self) -> Result<i64> {
400        let at = self.i;
401        let (v, n) = self.digits()?;
402        if n != 2 {
403            return Err(self.fail_at(ErrorKind::InvalidDate, at));
404        }
405        Ok(i64::from(v))
406    }
407
408    /// A three-letter name from `names`, ASCII case-insensitive; its index.
409    fn name(&mut self, names: &[&[u8; 3]]) -> Result<u32> {
410        let word = self.v.get(self.i..self.i + 3).unwrap_or(&[]);
411        let found = names
412            .iter()
413            .position(|n| n.eq_ignore_ascii_case(word))
414            .filter(|_| !self.v.get(self.i + 3).is_some_and(u8::is_ascii_alphabetic));
415        match found {
416            Some(idx) => {
417                self.i += 3;
418                Ok(idx as u32)
419            }
420            None => Err(self.fail(ErrorKind::InvalidDate)),
421        }
422    }
423
424    /// `hour ":" minute [ ":" second ]`; with `obsolete`, CFWS around the
425    /// colons.
426    fn time(&mut self, obsolete: bool) -> Result<(i64, i64, i64)> {
427        let at = self.i;
428        let hour = self.two()?;
429        let minute = {
430            self.colon(obsolete)?;
431            self.two()?
432        };
433        let mark = self.i;
434        let second = if obsolete {
435            let _ = self.cfws()?;
436            if self.peek() == Some(b':') {
437                self.colon(obsolete)?;
438                self.two()?
439            } else {
440                self.i = mark;
441                0
442            }
443        } else if self.peek() == Some(b':') {
444            self.i += 1;
445            self.two()?
446        } else {
447            0
448        };
449        if hour > 23 || minute > 59 || second > 60 {
450            return err(ErrorKind::InvalidDate, at);
451        }
452        Ok((hour, minute, second))
453    }
454
455    fn colon(&mut self, obsolete: bool) -> Result<()> {
456        if obsolete {
457            let _ = self.cfws()?;
458        }
459        if self.peek() != Some(b':') {
460            return Err(self.fail(ErrorKind::InvalidDate));
461        }
462        self.i += 1;
463        if obsolete {
464            let _ = self.cfws()?;
465        }
466        Ok(())
467    }
468
469    /// `( "+" / "-" ) 4DIGIT`, or with `obsolete` the section 4.3 names.
470    /// Returns the offset and whether it is unknown.
471    fn zone(&mut self, obsolete: bool) -> Result<(i16, bool)> {
472        let at = self.i;
473        match self.peek() {
474            Some(sign @ (b'+' | b'-')) => {
475                self.i += 1;
476                let (v, n) = self.digits()?;
477                if n != 4 || v % 100 > 59 {
478                    return err(ErrorKind::InvalidDate, at);
479                }
480                let minutes = (v / 100 * 60 + v % 100) as i16;
481                if sign == b'-' {
482                    Ok((-minutes, minutes == 0))
483                } else {
484                    Ok((minutes, false))
485                }
486            }
487            Some(b) if obsolete && b.is_ascii_alphabetic() => {
488                let n = self
489                    .v
490                    .get(self.i..)
491                    .unwrap_or(&[])
492                    .iter()
493                    .take_while(|b| b.is_ascii_alphabetic())
494                    .count();
495                let name = self.v.get(self.i..self.i + n).unwrap_or(&[]);
496                const ZONES: [(&[u8], i16); 10] = [
497                    (b"UT", 0),
498                    (b"GMT", 0),
499                    (b"EST", -300),
500                    (b"EDT", -240),
501                    (b"CST", -360),
502                    (b"CDT", -300),
503                    (b"MST", -420),
504                    (b"MDT", -360),
505                    (b"PST", -480),
506                    (b"PDT", -420),
507                ];
508                let found = ZONES.iter().find(|(z, _)| z.eq_ignore_ascii_case(name));
509                self.i += n;
510                match found {
511                    Some(&(_, off)) => Ok((off, false)),
512                    // A military zone (any letter except J) is read as
513                    // "-0000" (RFC 5322 section 4.3).
514                    None if n == 1 && !name.eq_ignore_ascii_case(b"j") => Ok((0, true)),
515                    None => err(ErrorKind::InvalidDate, at),
516                }
517            }
518            _ => Err(self.fail(ErrorKind::InvalidDate)),
519        }
520    }
521}
522
523#[cfg(test)]
524mod tests {
525    use super::*;
526
527    fn p(v: &[u8]) -> MailDate {
528        MailDate::parse(v, false).unwrap()
529    }
530
531    fn k(v: &[u8], obsolete: bool) -> ErrorKind {
532        MailDate::parse(v, obsolete).unwrap_err().kind()
533    }
534
535    fn text(d: MailDate) -> std::string::String {
536        let (b, n) = d.format();
537        std::string::String::from_utf8(b[..n].to_vec()).unwrap()
538    }
539
540    #[test]
541    fn test_mail_date_edge_cases() {
542        let d = p(b"Wed, 21 Oct 2026 17:38:00 +0200");
543        assert_eq!(d.utc(), p(b"21 Oct 2026 15:38:00 +0000").utc());
544        assert_eq!(
545            text(p(b"21 Oct 2026 17:38 +0200")),
546            "Wed, 21 Oct 2026 17:38:00 +0200"
547        );
548        assert_eq!(
549            text(p(b"1 Jan 2026 00:00:00 +0000")),
550            "Thu, 01 Jan 2026 00:00:00 +0000"
551        );
552        assert_eq!(
553            k(b"Mon, 21 Oct 2026 17:38:00 +0200", false),
554            ErrorKind::WeekdayMismatch
555        );
556        assert_eq!(p(b"21 Oct 2026 17:38 +2400").offset_minutes(), 1440);
557        assert_eq!(k(b"21 Oct 2026 17:38 +0060", false), ErrorKind::InvalidDate);
558        let u = p(b"21 Oct 2026 17:38 -0000");
559        assert!(u.offset_unknown() && u.offset_minutes() == 0);
560        assert_eq!(text(u), "Wed, 21 Oct 2026 17:38:00 -0000");
561        assert!(!p(b"21 Oct 2026 17:38 +0000").offset_unknown());
562        let c = p(b" (a (b)) Wed , 21 (x) oct 2026 17:38:00 (y)\r\n +0200 (z) ");
563        assert_eq!(c.utc(), d.utc());
564        let l = p(b"31 Dec 2016 23:59:60 +0000");
565        assert!(l.leap_second());
566        assert_eq!(l.utc(), p(b"31 Dec 2016 23:59:59 +0000").utc());
567        assert_eq!(k(b"30 Feb 2026 00:00 +0000", false), ErrorKind::InvalidDate);
568        assert_eq!(k(b"21 Oct 2026 24:00 +0000", false), ErrorKind::InvalidDate);
569        assert_eq!(
570            k(b"21 Oct 2026 17:38 +0000 x", false),
571            ErrorKind::TrailingData
572        );
573        assert_eq!(
574            k(b"21 Oct 2026 17:38 +0000 (", false),
575            ErrorKind::UnbalancedComment
576        );
577        assert_eq!(k(b"21 Oct 2026 17:38\r\n+0000", false), ErrorKind::BareCr);
578        assert_eq!(
579            k(b"21 Octo 2026 17:38 +0000", false),
580            ErrorKind::InvalidDate
581        );
582        assert_eq!(k(b"21 Oct 0000 17:38 +0000", false), ErrorKind::OutOfRange);
583        assert_eq!(k(b"21 Oct 10000 17:38 +0000", false), ErrorKind::OutOfRange);
584        assert_eq!(k(b"21Oct 2026 17:38 +0000", false), ErrorKind::InvalidDate);
585        assert_eq!(k(b"", false), ErrorKind::InvalidDate);
586        let deep = b"21 Oct 2026 17:38 +0000 (((((((((x)))))))))";
587        assert_eq!(k(deep, false), ErrorKind::CommentTooDeep);
588    }
589
590    #[test]
591    fn test_mail_date_obsolete_forms() {
592        assert_eq!(k(b"21 Oct 26 17:38 EDT", false), ErrorKind::InvalidDate);
593        let d = MailDate::parse(b"21 Oct 26 17:38 EDT", true).unwrap();
594        assert_eq!(
595            (d.offset_minutes(), text(d).as_str()),
596            (-240, "Wed, 21 Oct 2026 17:38:00 -0400")
597        );
598        assert_eq!(
599            text(MailDate::parse(b"1 Jan 70 00:00 GMT", true).unwrap()),
600            "Thu, 01 Jan 1970 00:00:00 +0000"
601        );
602        assert_eq!(
603            text(MailDate::parse(b"1 Jan 49 00:00 UT", true).unwrap()),
604            "Fri, 01 Jan 2049 00:00:00 +0000"
605        );
606        assert_eq!(
607            text(MailDate::parse(b"1 Jan 100 00:00 PST", true).unwrap()),
608            "Sat, 01 Jan 2000 00:00:00 -0800"
609        );
610        assert!(
611            MailDate::parse(b"1 Jan 2026 00:00 Z", true)
612                .unwrap()
613                .offset_unknown()
614        );
615        assert_eq!(k(b"1 Jan 2026 00:00 J", true), ErrorKind::InvalidDate);
616        assert_eq!(k(b"1 Jan 2026 00:00 XYZ", true), ErrorKind::InvalidDate);
617        assert_eq!(
618            MailDate::parse(b"1 Jan 2026 00 : 00 : 30 +0000", true)
619                .unwrap()
620                .utc()
621                % 60,
622            30
623        );
624        assert_eq!(
625            k(b"1 Jan 2026 00 : 00 +0000", false),
626            ErrorKind::InvalidDate
627        );
628    }
629
630    #[test]
631    fn test_mail_date_new_and_write() {
632        assert_eq!(
633            MailDate::new(0, 6000).unwrap_err().kind(),
634            ErrorKind::OutOfRange
635        );
636        assert_eq!(
637            MailDate::new(0, -6000).unwrap_err().kind(),
638            ErrorKind::OutOfRange
639        );
640        assert!(MailDate::new(0, 5999).is_ok() && MailDate::new(0, -5999).is_ok());
641        assert_eq!(
642            MailDate::new(MIN_SECS, -1).unwrap_err().kind(),
643            ErrorKind::OutOfRange
644        );
645        assert_eq!(
646            MailDate::new(MAX_SECS, 1).unwrap_err().kind(),
647            ErrorKind::OutOfRange
648        );
649        assert_eq!(
650            text(MailDate::new(MIN_SECS, 0).unwrap()),
651            "Mon, 01 Jan 0001 00:00:00 +0000"
652        );
653        let mut buf = [0u8; 30];
654        let mut out = crate::SliceSink::new(&mut buf);
655        assert_eq!(
656            MailDate::new(0, 0).unwrap().write_to(&mut out),
657            Err(WriteError::Full)
658        );
659        assert!(out.is_empty());
660        for secs in [-62_135_596_800i64, -1, 0, 1_792_540_800, 253_402_300_799] {
661            for off in [-5999i16, -300, 0, 330, 5999] {
662                if let Ok(d) = MailDate::new(secs, off) {
663                    let (b, n) = d.format();
664                    let back = MailDate::parse(&b[..n], false).unwrap();
665                    assert_eq!((back.utc(), back.offset_minutes()), (secs, off));
666                }
667            }
668        }
669    }
670}
parse_net/date/mail_date.rs

parse_net/date/
mail_date.rs
