chrono/format/
parse.rs

1// This is a part of Chrono.
2// Portions copyright (c) 2015, John Nagle.
3// See README.md and LICENSE.txt for details.
4
5//! Date and time parsing routines.
6
7use core::borrow::Borrow;
8use core::str;
9
10use super::scan;
11use super::{BAD_FORMAT, INVALID, OUT_OF_RANGE, TOO_LONG, TOO_SHORT};
12use super::{Fixed, InternalFixed, InternalInternal, Item, Numeric, Pad, Parsed};
13use super::{ParseError, ParseResult};
14use crate::{DateTime, FixedOffset, MappedLocalTime, NaiveDate, NaiveTime, Weekday};
15
16fn set_weekday_with_num_days_from_sunday(p: &mut Parsed, v: i64) -> ParseResult<()> {
17    p.set_weekday(match v {
18        0 => Weekday::Sun,
19        1 => Weekday::Mon,
20        2 => Weekday::Tue,
21        3 => Weekday::Wed,
22        4 => Weekday::Thu,
23        5 => Weekday::Fri,
24        6 => Weekday::Sat,
25        _ => return Err(OUT_OF_RANGE),
26    })
27}
28
29fn set_weekday_with_number_from_monday(p: &mut Parsed, v: i64) -> ParseResult<()> {
30    p.set_weekday(match v {
31        1 => Weekday::Mon,
32        2 => Weekday::Tue,
33        3 => Weekday::Wed,
34        4 => Weekday::Thu,
35        5 => Weekday::Fri,
36        6 => Weekday::Sat,
37        7 => Weekday::Sun,
38        _ => return Err(OUT_OF_RANGE),
39    })
40}
41
42fn parse_rfc2822<'a>(parsed: &mut Parsed, mut s: &'a str) -> ParseResult<(&'a str, ())> {
43    macro_rules! try_consume {
44        ($e:expr) => {{
45            let (s_, v) = $e?;
46            s = s_;
47            v
48        }};
49    }
50
51    // an adapted RFC 2822 syntax from Section 3.3 and 4.3:
52    //
53    // c-char      = <any char except '(', ')' and '\\'>
54    // c-escape    = "\" <any char>
55    // comment     = "(" *(comment / c-char / c-escape) ")" *S
56    // date-time   = [ day-of-week "," ] date 1*S time *S *comment
57    // day-of-week = *S day-name *S
58    // day-name    = "Mon" / "Tue" / "Wed" / "Thu" / "Fri" / "Sat" / "Sun"
59    // date        = day month year
60    // day         = *S 1*2DIGIT *S
61    // month       = 1*S month-name 1*S
62    // month-name  = "Jan" / "Feb" / "Mar" / "Apr" / "May" / "Jun" /
63    //               "Jul" / "Aug" / "Sep" / "Oct" / "Nov" / "Dec"
64    // year        = *S 2*DIGIT *S
65    // time        = time-of-day 1*S zone
66    // time-of-day = hour ":" minute [ ":" second ]
67    // hour        = *S 2DIGIT *S
68    // minute      = *S 2DIGIT *S
69    // second      = *S 2DIGIT *S
70    // zone        = ( "+" / "-" ) 4DIGIT /
71    //               "UT" / "GMT" /                  ; same as +0000
72    //               "EST" / "CST" / "MST" / "PST" / ; same as -0500 to -0800
73    //               "EDT" / "CDT" / "MDT" / "PDT" / ; same as -0400 to -0700
74    //               1*(%d65-90 / %d97-122)          ; same as -0000
75    //
76    // some notes:
77    //
78    // - quoted characters can be in any mixture of lower and upper cases.
79    //
80    // - we do not recognize a folding white space (FWS) or comment (CFWS).
81    //   for our purposes, instead, we accept any sequence of Unicode
82    //   white space characters (denoted here to `S`). For comments, we accept
83    //   any text within parentheses while respecting escaped parentheses.
84    //   Any actual RFC 2822 parser is expected to parse FWS and/or CFWS themselves
85    //   and replace it with a single SP (`%x20`); this is legitimate.
86    //
87    // - two-digit year < 50 should be interpreted by adding 2000.
88    //   two-digit year >= 50 or three-digit year should be interpreted
89    //   by adding 1900. note that four-or-more-digit years less than 1000
90    //   are *never* affected by this rule.
91    //
92    // - mismatching day-of-week is always an error, which is consistent to
93    //   Chrono's own rules.
94    //
95    // - zones can range from `-9959` to `+9959`, but `FixedOffset` does not
96    //   support offsets larger than 24 hours. this is not *that* problematic
97    //   since we do not directly go to a `DateTime` so one can recover
98    //   the offset information from `Parsed` anyway.
99
100    s = s.trim_start();
101
102    if let Ok((s_, weekday)) = scan::short_weekday(s) {
103        if !s_.starts_with(',') {
104            return Err(INVALID);
105        }
106        s = &s_[1..];
107        parsed.set_weekday(weekday)?;
108    }
109
110    s = s.trim_start();
111    parsed.set_day(try_consume!(scan::number(s, 1, 2)))?;
112    s = scan::space(s)?; // mandatory
113    parsed.set_month(1 + i64::from(try_consume!(scan::short_month0(s))))?;
114    s = scan::space(s)?; // mandatory
115
116    // distinguish two- and three-digit years from four-digit years
117    let prevlen = s.len();
118    let mut year = try_consume!(scan::number(s, 2, usize::MAX));
119    let yearlen = prevlen - s.len();
120    match (yearlen, year) {
121        (2, 0..=49) => {
122            year += 2000;
123        } //   47 -> 2047,   05 -> 2005
124        (2, 50..=99) => {
125            year += 1900;
126        } //   79 -> 1979
127        (3, _) => {
128            year += 1900;
129        } //  112 -> 2012,  009 -> 1909
130        (_, _) => {} // 1987 -> 1987, 0654 -> 0654
131    }
132    parsed.set_year(year)?;
133
134    s = scan::space(s)?; // mandatory
135    parsed.set_hour(try_consume!(scan::number(s, 2, 2)))?;
136    s = scan::char(s.trim_start(), b':')?.trim_start(); // *S ":" *S
137    parsed.set_minute(try_consume!(scan::number(s, 2, 2)))?;
138    if let Ok(s_) = scan::char(s.trim_start(), b':') {
139        // [ ":" *S 2DIGIT ]
140        parsed.set_second(try_consume!(scan::number(s_, 2, 2)))?;
141    }
142
143    s = scan::space(s)?; // mandatory
144    parsed.set_offset(i64::from(try_consume!(scan::timezone_offset_2822(s))))?;
145
146    // optional comments
147    while let Ok((s_out, ())) = scan::comment_2822(s) {
148        s = s_out;
149    }
150
151    Ok((s, ()))
152}
153
154pub(crate) fn parse_rfc3339(mut s: &str) -> ParseResult<DateTime<FixedOffset>> {
155    macro_rules! try_consume {
156        ($e:expr) => {{
157            let (s_, v) = $e?;
158            s = s_;
159            v
160        }};
161    }
162
163    // an adapted RFC 3339 syntax from Section 5.6:
164    //
165    // date-fullyear  = 4DIGIT
166    // date-month     = 2DIGIT ; 01-12
167    // date-mday      = 2DIGIT ; 01-28, 01-29, 01-30, 01-31 based on month/year
168    // time-hour      = 2DIGIT ; 00-23
169    // time-minute    = 2DIGIT ; 00-59
170    // time-second    = 2DIGIT ; 00-58, 00-59, 00-60 based on leap second rules
171    // time-secfrac   = "." 1*DIGIT
172    // time-numoffset = ("+" / "-") time-hour ":" time-minute
173    // time-offset    = "Z" / time-numoffset
174    // partial-time   = time-hour ":" time-minute ":" time-second [time-secfrac]
175    // full-date      = date-fullyear "-" date-month "-" date-mday
176    // full-time      = partial-time time-offset
177    // date-time      = full-date "T" full-time
178    //
179    // some notes:
180    //
181    // - quoted characters can be in any mixture of lower and upper cases.
182    //
183    // - it may accept any number of fractional digits for seconds.
184    //   for Chrono, this means that we should skip digits past first 9 digits.
185    //
186    // - unlike RFC 2822, the valid offset ranges from -23:59 to +23:59.
187    //   note that this restriction is unique to RFC 3339 and not ISO 8601.
188    //   since this is not a typical Chrono behavior, we check it earlier.
189    //
190    // - For readability a full-date and a full-time may be separated by a space character.
191
192    let bytes = s.as_bytes();
193    if bytes.len() < 19 {
194        return Err(TOO_SHORT);
195    }
196
197    let fixed = <&[u8; 19]>::try_from(&bytes[..19]).unwrap(); // we just checked the length
198    let year = digit(fixed, 0)? as u16 * 1000
199        + digit(fixed, 1)? as u16 * 100
200        + digit(fixed, 2)? as u16 * 10
201        + digit(fixed, 3)? as u16;
202    if bytes.get(4) != Some(&b'-') {
203        return Err(INVALID);
204    }
205
206    let month = digit(fixed, 5)? * 10 + digit(fixed, 6)?;
207    if bytes.get(7) != Some(&b'-') {
208        return Err(INVALID);
209    }
210
211    let day = digit(fixed, 8)? * 10 + digit(fixed, 9)?;
212    let date =
213        NaiveDate::from_ymd_opt(year as i32, month as u32, day as u32).ok_or(OUT_OF_RANGE)?;
214
215    if !matches!(bytes.get(10), Some(&b't' | &b'T' | &b' ')) {
216        return Err(INVALID);
217    }
218
219    let hour = digit(fixed, 11)? * 10 + digit(fixed, 12)?;
220    if bytes.get(13) != Some(&b':') {
221        return Err(INVALID);
222    }
223
224    let min = digit(fixed, 14)? * 10 + digit(fixed, 15)?;
225    if bytes.get(16) != Some(&b':') {
226        return Err(INVALID);
227    }
228
229    let sec = digit(fixed, 17)? * 10 + digit(fixed, 18)?;
230    let (sec, extra_nanos) = match sec {
231        60 => (59, 1_000_000_000), // rfc3339 allows leap seconds
232        _ => (sec, 0),
233    };
234
235    let nano = if bytes.get(19) == Some(&b'.') {
236        let nanosecond = try_consume!(scan::nanosecond(&s[20..]));
237        extra_nanos + nanosecond
238    } else {
239        s = &s[19..];
240        extra_nanos
241    };
242
243    let time = NaiveTime::from_hms_nano_opt(hour as u32, min as u32, sec as u32, nano)
244        .ok_or(OUT_OF_RANGE)?;
245
246    // Max for the hours field is `23`, and for the minutes field `59`.
247    let offset = try_consume!(scan::timezone_offset(s, |s| scan::char(s, b':'), true, false, true));
248    if !s.is_empty() {
249        return Err(TOO_LONG);
250    }
251
252    let tz = FixedOffset::east_opt(offset).ok_or(OUT_OF_RANGE)?;
253    Ok(match date.and_time(time).and_local_timezone(tz) {
254        MappedLocalTime::Single(dt) => dt,
255        // `FixedOffset::with_ymd_and_hms` doesn't return `MappedLocalTime::Ambiguous`
256        // and returns `MappedLocalTime::None` on invalid data
257        MappedLocalTime::Ambiguous(_, _) | MappedLocalTime::None => unreachable!(),
258    })
259}
260
261#[inline]
262fn digit(bytes: &[u8; 19], index: usize) -> ParseResult<u8> {
263    match bytes[index].is_ascii_digit() {
264        true => Ok(bytes[index] - b'0'),
265        false => Err(INVALID),
266    }
267}
268
269/// Tries to parse given string into `parsed` with given formatting items.
270/// Returns `Ok` when the entire string has been parsed (otherwise `parsed` should not be used).
271/// There should be no trailing string after parsing;
272/// use a stray [`Item::Space`](./enum.Item.html#variant.Space) to trim whitespaces.
273///
274/// This particular date and time parser is:
275///
276/// - Greedy. It will consume the longest possible prefix.
277///   For example, `April` is always consumed entirely when the long month name is requested;
278///   it equally accepts `Apr`, but prefers the longer prefix in this case.
279///
280/// - Padding-agnostic (for numeric items).
281///   The [`Pad`](./enum.Pad.html) field is completely ignored,
282///   so one can prepend any number of whitespace then any number of zeroes before numbers.
283///
284/// - (Still) obeying the intrinsic parsing width. This allows, for example, parsing `HHMMSS`.
285pub fn parse<'a, I, B>(parsed: &mut Parsed, s: &str, items: I) -> ParseResult<()>
286where
287    I: Iterator<Item = B>,
288    B: Borrow<Item<'a>>,
289{
290    match parse_internal(parsed, s, items) {
291        Ok("") => Ok(()),
292        Ok(_) => Err(TOO_LONG), // if there are trailing chars it is an error
293        Err(e) => Err(e),
294    }
295}
296
297/// Tries to parse given string into `parsed` with given formatting items.
298/// Returns `Ok` with a slice of the unparsed remainder.
299///
300/// This particular date and time parser is:
301///
302/// - Greedy. It will consume the longest possible prefix.
303///   For example, `April` is always consumed entirely when the long month name is requested;
304///   it equally accepts `Apr`, but prefers the longer prefix in this case.
305///
306/// - Padding-agnostic (for numeric items).
307///   The [`Pad`](./enum.Pad.html) field is completely ignored,
308///   so one can prepend any number of zeroes before numbers.
309///
310/// - (Still) obeying the intrinsic parsing width. This allows, for example, parsing `HHMMSS`.
311pub fn parse_and_remainder<'a, 'b, I, B>(
312    parsed: &mut Parsed,
313    s: &'b str,
314    items: I,
315) -> ParseResult<&'b str>
316where
317    I: Iterator<Item = B>,
318    B: Borrow<Item<'a>>,
319{
320    parse_internal(parsed, s, items)
321}
322
323fn parse_internal<'a, 'b, I, B>(
324    parsed: &mut Parsed,
325    mut s: &'b str,
326    items: I,
327) -> Result<&'b str, ParseError>
328where
329    I: Iterator<Item = B>,
330    B: Borrow<Item<'a>>,
331{
332    macro_rules! try_consume {
333        ($e:expr) => {{
334            match $e {
335                Ok((s_, v)) => {
336                    s = s_;
337                    v
338                }
339                Err(e) => return Err(e),
340            }
341        }};
342    }
343
344    for item in items {
345        match *item.borrow() {
346            Item::Literal(prefix) => {
347                if s.len() < prefix.len() {
348                    return Err(TOO_SHORT);
349                }
350                if !s.starts_with(prefix) {
351                    return Err(INVALID);
352                }
353                s = &s[prefix.len()..];
354            }
355
356            #[cfg(feature = "alloc")]
357            Item::OwnedLiteral(ref prefix) => {
358                if s.len() < prefix.len() {
359                    return Err(TOO_SHORT);
360                }
361                if !s.starts_with(&prefix[..]) {
362                    return Err(INVALID);
363                }
364                s = &s[prefix.len()..];
365            }
366
367            Item::Space(_) => {
368                s = s.trim_start();
369            }
370
371            #[cfg(feature = "alloc")]
372            Item::OwnedSpace(_) => {
373                s = s.trim_start();
374            }
375
376            Item::Numeric(ref spec, ref _pad) => {
377                use super::Numeric::*;
378                type Setter = fn(&mut Parsed, i64) -> ParseResult<()>;
379
380                let (width, signed, set): (usize, bool, Setter) = match *spec {
381                    Year => (4, true, Parsed::set_year),
382                    YearDiv100 => (2, false, Parsed::set_year_div_100),
383                    YearMod100 => (2, false, Parsed::set_year_mod_100),
384                    IsoYear => (4, true, Parsed::set_isoyear),
385                    IsoYearDiv100 => (2, false, Parsed::set_isoyear_div_100),
386                    IsoYearMod100 => (2, false, Parsed::set_isoyear_mod_100),
387                    Quarter => (1, false, Parsed::set_quarter),
388                    Month => (2, false, Parsed::set_month),
389                    Day => (2, false, Parsed::set_day),
390                    WeekFromSun => (2, false, Parsed::set_week_from_sun),
391                    WeekFromMon => (2, false, Parsed::set_week_from_mon),
392                    IsoWeek => (2, false, Parsed::set_isoweek),
393                    NumDaysFromSun => (1, false, set_weekday_with_num_days_from_sunday),
394                    WeekdayFromMon => (1, false, set_weekday_with_number_from_monday),
395                    Ordinal => (3, false, Parsed::set_ordinal),
396                    Hour => (2, false, Parsed::set_hour),
397                    Hour12 => (2, false, Parsed::set_hour12),
398                    Minute => (2, false, Parsed::set_minute),
399                    Second => (2, false, Parsed::set_second),
400                    Nanosecond => (9, false, Parsed::set_nanosecond),
401                    Timestamp => (usize::MAX, false, Parsed::set_timestamp),
402
403                    // for the future expansion
404                    Internal(ref int) => match int._dummy {},
405                };
406
407                s = s.trim_start();
408                let v = if signed {
409                    if s.starts_with('-') {
410                        let v = try_consume!(scan::number(&s[1..], 1, usize::MAX));
411                        0i64.checked_sub(v).ok_or(OUT_OF_RANGE)?
412                    } else if s.starts_with('+') {
413                        try_consume!(scan::number(&s[1..], 1, usize::MAX))
414                    } else {
415                        // if there is no explicit sign, we respect the original `width`
416                        try_consume!(scan::number(s, 1, width))
417                    }
418                } else {
419                    try_consume!(scan::number(s, 1, width))
420                };
421                set(parsed, v)?;
422            }
423
424            Item::Fixed(ref spec) => {
425                use super::Fixed::*;
426
427                match spec {
428                    &ShortMonthName => {
429                        let month0 = try_consume!(scan::short_month0(s));
430                        parsed.set_month(i64::from(month0) + 1)?;
431                    }
432
433                    &LongMonthName => {
434                        let month0 = try_consume!(scan::short_or_long_month0(s));
435                        parsed.set_month(i64::from(month0) + 1)?;
436                    }
437
438                    &ShortWeekdayName => {
439                        let weekday = try_consume!(scan::short_weekday(s));
440                        parsed.set_weekday(weekday)?;
441                    }
442
443                    &LongWeekdayName => {
444                        let weekday = try_consume!(scan::short_or_long_weekday(s));
445                        parsed.set_weekday(weekday)?;
446                    }
447
448                    &LowerAmPm | &UpperAmPm => {
449                        if s.len() < 2 {
450                            return Err(TOO_SHORT);
451                        }
452                        let ampm = match (s.as_bytes()[0] | 32, s.as_bytes()[1] | 32) {
453                            (b'a', b'm') => false,
454                            (b'p', b'm') => true,
455                            _ => return Err(INVALID),
456                        };
457                        parsed.set_ampm(ampm)?;
458                        s = &s[2..];
459                    }
460
461                    &Nanosecond => {
462                        if s.starts_with('.') {
463                            let nano = try_consume!(scan::nanosecond(&s[1..]));
464                            parsed.set_nanosecond(nano as i64)?;
465                        }
466                    }
467
468                    &Nanosecond3 => {
469                        if s.starts_with('.') {
470                            let nano = try_consume!(scan::nanosecond_fixed(&s[1..], 3));
471                            parsed.set_nanosecond(nano)?;
472                        }
473                    }
474
475                    &Nanosecond6 => {
476                        if s.starts_with('.') {
477                            let nano = try_consume!(scan::nanosecond_fixed(&s[1..], 6));
478                            parsed.set_nanosecond(nano)?;
479                        }
480                    }
481
482                    &Nanosecond9 => {
483                        if s.starts_with('.') {
484                            let nano = try_consume!(scan::nanosecond_fixed(&s[1..], 9));
485                            parsed.set_nanosecond(nano)?;
486                        }
487                    }
488
489                    &Internal(InternalFixed { val: InternalInternal::Nanosecond3NoDot }) => {
490                        if s.len() < 3 {
491                            return Err(TOO_SHORT);
492                        }
493                        let nano = try_consume!(scan::nanosecond_fixed(s, 3));
494                        parsed.set_nanosecond(nano)?;
495                    }
496
497                    &Internal(InternalFixed { val: InternalInternal::Nanosecond6NoDot }) => {
498                        if s.len() < 6 {
499                            return Err(TOO_SHORT);
500                        }
501                        let nano = try_consume!(scan::nanosecond_fixed(s, 6));
502                        parsed.set_nanosecond(nano)?;
503                    }
504
505                    &Internal(InternalFixed { val: InternalInternal::Nanosecond9NoDot }) => {
506                        if s.len() < 9 {
507                            return Err(TOO_SHORT);
508                        }
509                        let nano = try_consume!(scan::nanosecond_fixed(s, 9));
510                        parsed.set_nanosecond(nano)?;
511                    }
512
513                    &TimezoneName => {
514                        try_consume!(Ok((s.trim_start_matches(|c: char| !c.is_whitespace()), ())));
515                    }
516
517                    &TimezoneOffsetColon
518                    | &TimezoneOffsetDoubleColon
519                    | &TimezoneOffsetTripleColon
520                    | &TimezoneOffset => {
521                        let offset = try_consume!(scan::timezone_offset(
522                            s.trim_start(),
523                            scan::colon_or_space,
524                            false,
525                            false,
526                            true,
527                        ));
528                        parsed.set_offset(i64::from(offset))?;
529                    }
530
531                    &TimezoneOffsetColonZ | &TimezoneOffsetZ => {
532                        let offset = try_consume!(scan::timezone_offset(
533                            s.trim_start(),
534                            scan::colon_or_space,
535                            true,
536                            false,
537                            true,
538                        ));
539                        parsed.set_offset(i64::from(offset))?;
540                    }
541                    &Internal(InternalFixed {
542                        val: InternalInternal::TimezoneOffsetPermissive,
543                    }) => {
544                        let offset = try_consume!(scan::timezone_offset(
545                            s.trim_start(),
546                            scan::colon_or_space,
547                            true,
548                            true,
549                            true,
550                        ));
551                        parsed.set_offset(i64::from(offset))?;
552                    }
553
554                    &RFC2822 => try_consume!(parse_rfc2822(parsed, s)),
555                    &RFC3339 => {
556                        // Used for the `%+` specifier, which has the description:
557                        // "Same as `%Y-%m-%dT%H:%M:%S%.f%:z` (...)
558                        // This format also supports having a `Z` or `UTC` in place of `%:z`."
559                        // Use the relaxed parser to match this description.
560                        try_consume!(parse_rfc3339_relaxed(parsed, s))
561                    }
562                }
563            }
564
565            Item::Error => {
566                return Err(BAD_FORMAT);
567            }
568        }
569    }
570    Ok(s)
571}
572
573/// Accepts a relaxed form of RFC3339.
574/// A space or a 'T' are accepted as the separator between the date and time
575/// parts. Additional spaces are allowed between each component.
576///
577/// All of these examples are equivalent:
578/// ```
579/// # use chrono::{DateTime, offset::FixedOffset};
580/// "2012-12-12T12:12:12Z".parse::<DateTime<FixedOffset>>()?;
581/// "2012-12-12 12:12:12Z".parse::<DateTime<FixedOffset>>()?;
582/// "2012-  12-12T12:  12:12Z".parse::<DateTime<FixedOffset>>()?;
583/// # Ok::<(), chrono::ParseError>(())
584/// ```
585impl str::FromStr for DateTime<FixedOffset> {
586    type Err = ParseError;
587
588    fn from_str(s: &str) -> ParseResult<DateTime<FixedOffset>> {
589        let mut parsed = Parsed::new();
590        let (s, _) = parse_rfc3339_relaxed(&mut parsed, s)?;
591        if !s.trim_start().is_empty() {
592            return Err(TOO_LONG);
593        }
594        parsed.to_datetime()
595    }
596}
597
598/// Accepts a relaxed form of RFC3339.
599///
600/// Differences with RFC3339:
601/// - Values don't require padding to two digits.
602/// - Years outside the range 0...=9999 are accepted, but they must include a sign.
603/// - `UTC` is accepted as a valid timezone name/offset (for compatibility with the debug format of
604///   `DateTime<Utc>`.
605/// - There can be spaces between any of the components.
606/// - The colon in the offset may be missing.
607fn parse_rfc3339_relaxed<'a>(parsed: &mut Parsed, mut s: &'a str) -> ParseResult<(&'a str, ())> {
608    const DATE_ITEMS: &[Item<'static>] = &[
609        Item::Numeric(Numeric::Year, Pad::Zero),
610        Item::Space(""),
611        Item::Literal("-"),
612        Item::Numeric(Numeric::Month, Pad::Zero),
613        Item::Space(""),
614        Item::Literal("-"),
615        Item::Numeric(Numeric::Day, Pad::Zero),
616    ];
617    const TIME_ITEMS: &[Item<'static>] = &[
618        Item::Numeric(Numeric::Hour, Pad::Zero),
619        Item::Space(""),
620        Item::Literal(":"),
621        Item::Numeric(Numeric::Minute, Pad::Zero),
622        Item::Space(""),
623        Item::Literal(":"),
624        Item::Numeric(Numeric::Second, Pad::Zero),
625        Item::Fixed(Fixed::Nanosecond),
626        Item::Space(""),
627    ];
628
629    s = parse_internal(parsed, s, DATE_ITEMS.iter())?;
630
631    s = match s.as_bytes().first() {
632        Some(&b't' | &b'T' | &b' ') => &s[1..],
633        Some(_) => return Err(INVALID),
634        None => return Err(TOO_SHORT),
635    };
636
637    s = parse_internal(parsed, s, TIME_ITEMS.iter())?;
638    s = s.trim_start();
639    let (s, offset) = if s.len() >= 3 && "UTC".as_bytes().eq_ignore_ascii_case(&s.as_bytes()[..3]) {
640        (&s[3..], 0)
641    } else {
642        scan::timezone_offset(s, scan::colon_or_space, true, false, true)?
643    };
644    parsed.set_offset(i64::from(offset))?;
645    Ok((s, ()))
646}
647
648#[cfg(test)]
649mod tests {
650    use crate::format::*;
651    use crate::{DateTime, FixedOffset, NaiveDateTime, TimeZone, Timelike, Utc};
652
653    macro_rules! parsed {
654        ($($k:ident: $v:expr),*) => (#[allow(unused_mut)] {
655            let mut expected = Parsed::new();
656            $(expected.$k = Some($v);)*
657            Ok(expected)
658        });
659    }
660
661    #[test]
662    fn test_parse_whitespace_and_literal() {
663        use crate::format::Item::{Literal, Space};
664
665        // empty string
666        parses("", &[]);
667        check(" ", &[], Err(TOO_LONG));
668        check("a", &[], Err(TOO_LONG));
669        check("abc", &[], Err(TOO_LONG));
670        check("🤠", &[], Err(TOO_LONG));
671
672        // whitespaces
673        parses("", &[Space("")]);
674        parses(" ", &[Space(" ")]);
675        parses("  ", &[Space("  ")]);
676        parses("   ", &[Space("   ")]);
677        parses(" ", &[Space("")]);
678        parses("  ", &[Space(" ")]);
679        parses("   ", &[Space("  ")]);
680        parses("    ", &[Space("  ")]);
681        parses("", &[Space(" ")]);
682        parses(" ", &[Space("  ")]);
683        parses("  ", &[Space("   ")]);
684        parses("  ", &[Space("  "), Space("  ")]);
685        parses("   ", &[Space("  "), Space("  ")]);
686        parses("  ", &[Space(" "), Space(" ")]);
687        parses("   ", &[Space("  "), Space(" ")]);
688        parses("   ", &[Space(" "), Space("  ")]);
689        parses("   ", &[Space(" "), Space(" "), Space(" ")]);
690        parses("\t", &[Space("")]);
691        parses(" \n\r  \n", &[Space("")]);
692        parses("\t", &[Space("\t")]);
693        parses("\t", &[Space(" ")]);
694        parses(" ", &[Space("\t")]);
695        parses("\t\r", &[Space("\t\r")]);
696        parses("\t\r ", &[Space("\t\r ")]);
697        parses("\t \r", &[Space("\t \r")]);
698        parses(" \t\r", &[Space(" \t\r")]);
699        parses(" \n\r  \n", &[Space(" \n\r  \n")]);
700        parses(" \t\n", &[Space(" \t")]);
701        parses(" \n\t", &[Space(" \t\n")]);
702        parses("\u{2002}", &[Space("\u{2002}")]);
703        // most unicode whitespace characters
704        parses(
705            "\u{00A0}\u{1680}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{3000}",
706            &[Space(
707                "\u{00A0}\u{1680}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{3000}",
708            )],
709        );
710        // most unicode whitespace characters
711        parses(
712            "\u{00A0}\u{1680}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{3000}",
713            &[
714                Space("\u{00A0}\u{1680}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}"),
715                Space("\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{3000}"),
716            ],
717        );
718        check("a", &[Space("")], Err(TOO_LONG));
719        check("a", &[Space(" ")], Err(TOO_LONG));
720        // a Space containing a literal does not match a literal
721        check("a", &[Space("a")], Err(TOO_LONG));
722        check("abc", &[Space("")], Err(TOO_LONG));
723        check("abc", &[Space(" ")], Err(TOO_LONG));
724        check(" abc", &[Space("")], Err(TOO_LONG));
725        check(" abc", &[Space(" ")], Err(TOO_LONG));
726
727        // `\u{0363}` is combining diacritic mark "COMBINING LATIN SMALL LETTER A"
728
729        // literal
730        parses("", &[Literal("")]);
731        check("", &[Literal("a")], Err(TOO_SHORT));
732        check(" ", &[Literal("a")], Err(INVALID));
733        parses("a", &[Literal("a")]);
734        parses("+", &[Literal("+")]);
735        parses("-", &[Literal("-")]);
736        parses("−", &[Literal("−")]); // MINUS SIGN (U+2212)
737        parses(" ", &[Literal(" ")]); // a Literal may contain whitespace and match whitespace
738        check("aa", &[Literal("a")], Err(TOO_LONG));
739        check("🤠", &[Literal("a")], Err(INVALID));
740        check("A", &[Literal("a")], Err(INVALID));
741        check("a", &[Literal("z")], Err(INVALID));
742        check("a", &[Literal("🤠")], Err(TOO_SHORT));
743        check("a", &[Literal("\u{0363}a")], Err(TOO_SHORT));
744        check("\u{0363}a", &[Literal("a")], Err(INVALID));
745        parses("\u{0363}a", &[Literal("\u{0363}a")]);
746        check("a", &[Literal("ab")], Err(TOO_SHORT));
747        parses("xy", &[Literal("xy")]);
748        parses("xy", &[Literal("x"), Literal("y")]);
749        parses("1", &[Literal("1")]);
750        parses("1234", &[Literal("1234")]);
751        parses("+1234", &[Literal("+1234")]);
752        parses("-1234", &[Literal("-1234")]);
753        parses("−1234", &[Literal("−1234")]); // MINUS SIGN (U+2212)
754        parses("PST", &[Literal("PST")]);
755        parses("🤠", &[Literal("🤠")]);
756        parses("🤠a", &[Literal("🤠"), Literal("a")]);
757        parses("🤠a🤠", &[Literal("🤠"), Literal("a🤠")]);
758        parses("a🤠b", &[Literal("a"), Literal("🤠"), Literal("b")]);
759        // literals can be together
760        parses("xy", &[Literal("xy")]);
761        parses("xyz", &[Literal("xyz")]);
762        // or literals can be apart
763        parses("xy", &[Literal("x"), Literal("y")]);
764        parses("xyz", &[Literal("x"), Literal("yz")]);
765        parses("xyz", &[Literal("xy"), Literal("z")]);
766        parses("xyz", &[Literal("x"), Literal("y"), Literal("z")]);
767        //
768        check("x y", &[Literal("x"), Literal("y")], Err(INVALID));
769        parses("xy", &[Literal("x"), Space(""), Literal("y")]);
770        parses("x y", &[Literal("x"), Space(""), Literal("y")]);
771        parses("x y", &[Literal("x"), Space(" "), Literal("y")]);
772
773        // whitespaces + literals
774        parses("a\n", &[Literal("a"), Space("\n")]);
775        parses("\tab\n", &[Space("\t"), Literal("ab"), Space("\n")]);
776        parses(
777            "ab\tcd\ne",
778            &[Literal("ab"), Space("\t"), Literal("cd"), Space("\n"), Literal("e")],
779        );
780        parses(
781            "+1ab\tcd\r\n+,.",
782            &[Literal("+1ab"), Space("\t"), Literal("cd"), Space("\r\n"), Literal("+,.")],
783        );
784        // whitespace and literals can be intermixed
785        parses("a\tb", &[Literal("a\tb")]);
786        parses("a\tb", &[Literal("a"), Space("\t"), Literal("b")]);
787    }
788
789    #[test]
790    fn test_parse_numeric() {
791        use crate::format::Item::{Literal, Space};
792        use crate::format::Numeric::*;
793
794        // numeric
795        check("1987", &[num(Year)], parsed!(year: 1987));
796        check("1987 ", &[num(Year)], Err(TOO_LONG));
797        check("0x12", &[num(Year)], Err(TOO_LONG)); // `0` is parsed
798        check("x123", &[num(Year)], Err(INVALID));
799        check("o123", &[num(Year)], Err(INVALID));
800        check("2015", &[num(Year)], parsed!(year: 2015));
801        check("0000", &[num(Year)], parsed!(year: 0));
802        check("9999", &[num(Year)], parsed!(year: 9999));
803        check(" \t987", &[num(Year)], parsed!(year: 987));
804        check(" \t987", &[Space(" \t"), num(Year)], parsed!(year: 987));
805        check(" \t987🤠", &[Space(" \t"), num(Year), Literal("🤠")], parsed!(year: 987));
806        check("987🤠", &[num(Year), Literal("🤠")], parsed!(year: 987));
807        check("5", &[num(Year)], parsed!(year: 5));
808        check("5\0", &[num(Year)], Err(TOO_LONG));
809        check("\x005", &[num(Year)], Err(INVALID));
810        check("", &[num(Year)], Err(TOO_SHORT));
811        check("12345", &[num(Year), Literal("5")], parsed!(year: 1234));
812        check("12345", &[nums(Year), Literal("5")], parsed!(year: 1234));
813        check("12345", &[num0(Year), Literal("5")], parsed!(year: 1234));
814        check("12341234", &[num(Year), num(Year)], parsed!(year: 1234));
815        check("1234 1234", &[num(Year), num(Year)], parsed!(year: 1234));
816        check("1234 1234", &[num(Year), Space(" "), num(Year)], parsed!(year: 1234));
817        check("1234 1235", &[num(Year), num(Year)], Err(IMPOSSIBLE));
818        check("1234 1234", &[num(Year), Literal("x"), num(Year)], Err(INVALID));
819        check("1234x1234", &[num(Year), Literal("x"), num(Year)], parsed!(year: 1234));
820        check("1234 x 1234", &[num(Year), Literal("x"), num(Year)], Err(INVALID));
821        check("1234xx1234", &[num(Year), Literal("x"), num(Year)], Err(INVALID));
822        check("1234xx1234", &[num(Year), Literal("xx"), num(Year)], parsed!(year: 1234));
823        check(
824            "1234 x 1234",
825            &[num(Year), Space(" "), Literal("x"), Space(" "), num(Year)],
826            parsed!(year: 1234),
827        );
828        check(
829            "1234 x 1235",
830            &[num(Year), Space(" "), Literal("x"), Space(" "), Literal("1235")],
831            parsed!(year: 1234),
832        );
833
834        // signed numeric
835        check("-42", &[num(Year)], parsed!(year: -42));
836        check("+42", &[num(Year)], parsed!(year: 42));
837        check("-0042", &[num(Year)], parsed!(year: -42));
838        check("+0042", &[num(Year)], parsed!(year: 42));
839        check("-42195", &[num(Year)], parsed!(year: -42195));
840        check("−42195", &[num(Year)], Err(INVALID)); // MINUS SIGN (U+2212)
841        check("+42195", &[num(Year)], parsed!(year: 42195));
842        check("  -42195", &[num(Year)], parsed!(year: -42195));
843        check(" +42195", &[num(Year)], parsed!(year: 42195));
844        check("  -42195", &[num(Year)], parsed!(year: -42195));
845        check("  +42195", &[num(Year)], parsed!(year: 42195));
846        check("-42195 ", &[num(Year)], Err(TOO_LONG));
847        check("+42195 ", &[num(Year)], Err(TOO_LONG));
848        check("  -   42", &[num(Year)], Err(INVALID));
849        check("  +   42", &[num(Year)], Err(INVALID));
850        check("  -42195", &[Space("  "), num(Year)], parsed!(year: -42195));
851        check("  −42195", &[Space("  "), num(Year)], Err(INVALID)); // MINUS SIGN (U+2212)
852        check("  +42195", &[Space("  "), num(Year)], parsed!(year: 42195));
853        check("  -   42", &[Space("  "), num(Year)], Err(INVALID));
854        check("  +   42", &[Space("  "), num(Year)], Err(INVALID));
855        check("-", &[num(Year)], Err(TOO_SHORT));
856        check("+", &[num(Year)], Err(TOO_SHORT));
857
858        // unsigned numeric
859        check("345", &[num(Ordinal)], parsed!(ordinal: 345));
860        check("+345", &[num(Ordinal)], Err(INVALID));
861        check("-345", &[num(Ordinal)], Err(INVALID));
862        check(" 345", &[num(Ordinal)], parsed!(ordinal: 345));
863        check("−345", &[num(Ordinal)], Err(INVALID)); // MINUS SIGN (U+2212)
864        check("345 ", &[num(Ordinal)], Err(TOO_LONG));
865        check(" 345", &[Space(" "), num(Ordinal)], parsed!(ordinal: 345));
866        check("345 ", &[num(Ordinal), Space(" ")], parsed!(ordinal: 345));
867        check("345🤠 ", &[num(Ordinal), Literal("🤠"), Space(" ")], parsed!(ordinal: 345));
868        check("345🤠", &[num(Ordinal)], Err(TOO_LONG));
869        check("\u{0363}345", &[num(Ordinal)], Err(INVALID));
870        check(" +345", &[num(Ordinal)], Err(INVALID));
871        check(" -345", &[num(Ordinal)], Err(INVALID));
872        check("\t345", &[Space("\t"), num(Ordinal)], parsed!(ordinal: 345));
873        check(" +345", &[Space(" "), num(Ordinal)], Err(INVALID));
874        check(" -345", &[Space(" "), num(Ordinal)], Err(INVALID));
875
876        // various numeric fields
877        check("1234 5678", &[num(Year), num(IsoYear)], parsed!(year: 1234, isoyear: 5678));
878        check("1234 5678", &[num(Year), num(IsoYear)], parsed!(year: 1234, isoyear: 5678));
879        check(
880            "12 34 56 78",
881            &[num(YearDiv100), num(YearMod100), num(IsoYearDiv100), num(IsoYearMod100)],
882            parsed!(year_div_100: 12, year_mod_100: 34, isoyear_div_100: 56, isoyear_mod_100: 78),
883        );
884        check(
885            "1 1 2 3 4 5",
886            &[
887                num(Quarter),
888                num(Month),
889                num(Day),
890                num(WeekFromSun),
891                num(NumDaysFromSun),
892                num(IsoWeek),
893            ],
894            parsed!(quarter: 1, month: 1, day: 2, week_from_sun: 3, weekday: Weekday::Thu, isoweek: 5),
895        );
896        check(
897            "6 7 89 01",
898            &[num(WeekFromMon), num(WeekdayFromMon), num(Ordinal), num(Hour12)],
899            parsed!(week_from_mon: 6, weekday: Weekday::Sun, ordinal: 89, hour_mod_12: 1),
900        );
901        check(
902            "23 45 6 78901234 567890123",
903            &[num(Hour), num(Minute), num(Second), num(Nanosecond), num(Timestamp)],
904            parsed!(hour_div_12: 1, hour_mod_12: 11, minute: 45, second: 6, nanosecond: 78_901_234, timestamp: 567_890_123),
905        );
906    }
907
908    #[test]
909    fn test_parse_fixed() {
910        use crate::format::Fixed::*;
911        use crate::format::Item::{Literal, Space};
912
913        // fixed: month and weekday names
914        check("apr", &[fixed(ShortMonthName)], parsed!(month: 4));
915        check("Apr", &[fixed(ShortMonthName)], parsed!(month: 4));
916        check("APR", &[fixed(ShortMonthName)], parsed!(month: 4));
917        check("ApR", &[fixed(ShortMonthName)], parsed!(month: 4));
918        check("\u{0363}APR", &[fixed(ShortMonthName)], Err(INVALID));
919        check("April", &[fixed(ShortMonthName)], Err(TOO_LONG)); // `Apr` is parsed
920        check("A", &[fixed(ShortMonthName)], Err(TOO_SHORT));
921        check("Sol", &[fixed(ShortMonthName)], Err(INVALID));
922        check("Apr", &[fixed(LongMonthName)], parsed!(month: 4));
923        check("Apri", &[fixed(LongMonthName)], Err(TOO_LONG)); // `Apr` is parsed
924        check("April", &[fixed(LongMonthName)], parsed!(month: 4));
925        check("Aprill", &[fixed(LongMonthName)], Err(TOO_LONG));
926        check("Aprill", &[fixed(LongMonthName), Literal("l")], parsed!(month: 4));
927        check("Aprl", &[fixed(LongMonthName), Literal("l")], parsed!(month: 4));
928        check("April", &[fixed(LongMonthName), Literal("il")], Err(TOO_SHORT)); // do not backtrack
929        check("thu", &[fixed(ShortWeekdayName)], parsed!(weekday: Weekday::Thu));
930        check("Thu", &[fixed(ShortWeekdayName)], parsed!(weekday: Weekday::Thu));
931        check("THU", &[fixed(ShortWeekdayName)], parsed!(weekday: Weekday::Thu));
932        check("tHu", &[fixed(ShortWeekdayName)], parsed!(weekday: Weekday::Thu));
933        check("Thursday", &[fixed(ShortWeekdayName)], Err(TOO_LONG)); // `Thu` is parsed
934        check("T", &[fixed(ShortWeekdayName)], Err(TOO_SHORT));
935        check("The", &[fixed(ShortWeekdayName)], Err(INVALID));
936        check("Nop", &[fixed(ShortWeekdayName)], Err(INVALID));
937        check("Thu", &[fixed(LongWeekdayName)], parsed!(weekday: Weekday::Thu));
938        check("Thur", &[fixed(LongWeekdayName)], Err(TOO_LONG)); // `Thu` is parsed
939        check("Thurs", &[fixed(LongWeekdayName)], Err(TOO_LONG)); // `Thu` is parsed
940        check("Thursday", &[fixed(LongWeekdayName)], parsed!(weekday: Weekday::Thu));
941        check("Thursdays", &[fixed(LongWeekdayName)], Err(TOO_LONG));
942        check("Thursdays", &[fixed(LongWeekdayName), Literal("s")], parsed!(weekday: Weekday::Thu));
943        check("Thus", &[fixed(LongWeekdayName), Literal("s")], parsed!(weekday: Weekday::Thu));
944        check("Thursday", &[fixed(LongWeekdayName), Literal("rsday")], Err(TOO_SHORT)); // do not backtrack
945
946        // fixed: am/pm
947        check("am", &[fixed(LowerAmPm)], parsed!(hour_div_12: 0));
948        check("pm", &[fixed(LowerAmPm)], parsed!(hour_div_12: 1));
949        check("AM", &[fixed(LowerAmPm)], parsed!(hour_div_12: 0));
950        check("PM", &[fixed(LowerAmPm)], parsed!(hour_div_12: 1));
951        check("am", &[fixed(UpperAmPm)], parsed!(hour_div_12: 0));
952        check("pm", &[fixed(UpperAmPm)], parsed!(hour_div_12: 1));
953        check("AM", &[fixed(UpperAmPm)], parsed!(hour_div_12: 0));
954        check("PM", &[fixed(UpperAmPm)], parsed!(hour_div_12: 1));
955        check("Am", &[fixed(LowerAmPm)], parsed!(hour_div_12: 0));
956        check(" Am", &[Space(" "), fixed(LowerAmPm)], parsed!(hour_div_12: 0));
957        check("Am🤠", &[fixed(LowerAmPm), Literal("🤠")], parsed!(hour_div_12: 0));
958        check("🤠Am", &[Literal("🤠"), fixed(LowerAmPm)], parsed!(hour_div_12: 0));
959        check("\u{0363}am", &[fixed(LowerAmPm)], Err(INVALID));
960        check("\u{0360}am", &[fixed(LowerAmPm)], Err(INVALID));
961        check(" Am", &[fixed(LowerAmPm)], Err(INVALID));
962        check("Am ", &[fixed(LowerAmPm)], Err(TOO_LONG));
963        check("a.m.", &[fixed(LowerAmPm)], Err(INVALID));
964        check("A.M.", &[fixed(LowerAmPm)], Err(INVALID));
965        check("ame", &[fixed(LowerAmPm)], Err(TOO_LONG)); // `am` is parsed
966        check("a", &[fixed(LowerAmPm)], Err(TOO_SHORT));
967        check("p", &[fixed(LowerAmPm)], Err(TOO_SHORT));
968        check("x", &[fixed(LowerAmPm)], Err(TOO_SHORT));
969        check("xx", &[fixed(LowerAmPm)], Err(INVALID));
970        check("", &[fixed(LowerAmPm)], Err(TOO_SHORT));
971    }
972
973    #[test]
974    fn test_parse_fixed_nanosecond() {
975        use crate::format::Fixed::{Nanosecond, Nanosecond3, Nanosecond6, Nanosecond9};
976        use crate::format::InternalInternal::*;
977        use crate::format::Item::Literal;
978        use crate::format::Numeric::Second;
979
980        // fixed: dot plus nanoseconds
981        check("", &[fixed(Nanosecond)], parsed!()); // no field set, but not an error
982        check(".", &[fixed(Nanosecond)], Err(TOO_SHORT));
983        check("4", &[fixed(Nanosecond)], Err(TOO_LONG)); // never consumes `4`
984        check("4", &[fixed(Nanosecond), num(Second)], parsed!(second: 4));
985        check(".0", &[fixed(Nanosecond)], parsed!(nanosecond: 0));
986        check(".4", &[fixed(Nanosecond)], parsed!(nanosecond: 400_000_000));
987        check(".42", &[fixed(Nanosecond)], parsed!(nanosecond: 420_000_000));
988        check(".421", &[fixed(Nanosecond)], parsed!(nanosecond: 421_000_000));
989        check(".42195", &[fixed(Nanosecond)], parsed!(nanosecond: 421_950_000));
990        check(".421951", &[fixed(Nanosecond)], parsed!(nanosecond: 421_951_000));
991        check(".4219512", &[fixed(Nanosecond)], parsed!(nanosecond: 421_951_200));
992        check(".42195123", &[fixed(Nanosecond)], parsed!(nanosecond: 421_951_230));
993        check(".421950803", &[fixed(Nanosecond)], parsed!(nanosecond: 421_950_803));
994        check(".4219508035", &[fixed(Nanosecond)], parsed!(nanosecond: 421_950_803));
995        check(".42195080354", &[fixed(Nanosecond)], parsed!(nanosecond: 421_950_803));
996        check(".421950803547", &[fixed(Nanosecond)], parsed!(nanosecond: 421_950_803));
997        check(".000000003", &[fixed(Nanosecond)], parsed!(nanosecond: 3));
998        check(".0000000031", &[fixed(Nanosecond)], parsed!(nanosecond: 3));
999        check(".0000000035", &[fixed(Nanosecond)], parsed!(nanosecond: 3));
1000        check(".000000003547", &[fixed(Nanosecond)], parsed!(nanosecond: 3));
1001        check(".0000000009", &[fixed(Nanosecond)], parsed!(nanosecond: 0));
1002        check(".000000000547", &[fixed(Nanosecond)], parsed!(nanosecond: 0));
1003        check(".0000000009999999999999999999999999", &[fixed(Nanosecond)], parsed!(nanosecond: 0));
1004        check(".4🤠", &[fixed(Nanosecond), Literal("🤠")], parsed!(nanosecond: 400_000_000));
1005        check(".4x", &[fixed(Nanosecond)], Err(TOO_LONG));
1006        check(".  4", &[fixed(Nanosecond)], Err(INVALID));
1007        check("  .4", &[fixed(Nanosecond)], Err(TOO_LONG)); // no automatic trimming
1008
1009        // fixed-length fractions of a second
1010        check("", &[fixed(Nanosecond3)], parsed!()); // no field set, but not an error
1011        check("4", &[fixed(Nanosecond3)], Err(TOO_LONG)); // never consumes `4`
1012        check(".12", &[fixed(Nanosecond3)], Err(TOO_SHORT));
1013        check(".123", &[fixed(Nanosecond3)], parsed!(nanosecond: 123_000_000));
1014        check(".1234", &[fixed(Nanosecond3)], Err(TOO_LONG));
1015        check(".1234", &[fixed(Nanosecond3), Literal("4")], parsed!(nanosecond: 123_000_000));
1016
1017        check("", &[fixed(Nanosecond6)], parsed!()); // no field set, but not an error
1018        check("4", &[fixed(Nanosecond6)], Err(TOO_LONG)); // never consumes `4`
1019        check(".12345", &[fixed(Nanosecond6)], Err(TOO_SHORT));
1020        check(".123456", &[fixed(Nanosecond6)], parsed!(nanosecond: 123_456_000));
1021        check(".1234567", &[fixed(Nanosecond6)], Err(TOO_LONG));
1022        check(".1234567", &[fixed(Nanosecond6), Literal("7")], parsed!(nanosecond: 123_456_000));
1023
1024        check("", &[fixed(Nanosecond9)], parsed!()); // no field set, but not an error
1025        check("4", &[fixed(Nanosecond9)], Err(TOO_LONG)); // never consumes `4`
1026        check(".12345678", &[fixed(Nanosecond9)], Err(TOO_SHORT));
1027        check(".123456789", &[fixed(Nanosecond9)], parsed!(nanosecond: 123_456_789));
1028        check(".1234567890", &[fixed(Nanosecond9)], Err(TOO_LONG));
1029        check(".1234567890", &[fixed(Nanosecond9), Literal("0")], parsed!(nanosecond: 123_456_789));
1030
1031        // fixed: nanoseconds without the dot
1032        check("", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_SHORT));
1033        check(".", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_SHORT));
1034        check("0", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_SHORT));
1035        check("4", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_SHORT));
1036        check("42", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_SHORT));
1037        check("421", &[internal_fixed(Nanosecond3NoDot)], parsed!(nanosecond: 421_000_000));
1038        check("4210", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_LONG));
1039        check(
1040            "42143",
1041            &[internal_fixed(Nanosecond3NoDot), num(Second)],
1042            parsed!(nanosecond: 421_000_000, second: 43),
1043        );
1044        check(
1045            "421🤠",
1046            &[internal_fixed(Nanosecond3NoDot), Literal("🤠")],
1047            parsed!(nanosecond: 421_000_000),
1048        );
1049        check(
1050            "🤠421",
1051            &[Literal("🤠"), internal_fixed(Nanosecond3NoDot)],
1052            parsed!(nanosecond: 421_000_000),
1053        );
1054        check("42195", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_LONG));
1055        check("123456789", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_LONG));
1056        check("4x", &[internal_fixed(Nanosecond3NoDot)], Err(TOO_SHORT));
1057        check("  4", &[internal_fixed(Nanosecond3NoDot)], Err(INVALID));
1058        check(".421", &[internal_fixed(Nanosecond3NoDot)], Err(INVALID));
1059
1060        check("", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_SHORT));
1061        check(".", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_SHORT));
1062        check("0", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_SHORT));
1063        check("1234", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_SHORT));
1064        check("12345", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_SHORT));
1065        check("421950", &[internal_fixed(Nanosecond6NoDot)], parsed!(nanosecond: 421_950_000));
1066        check("000003", &[internal_fixed(Nanosecond6NoDot)], parsed!(nanosecond: 3000));
1067        check("000000", &[internal_fixed(Nanosecond6NoDot)], parsed!(nanosecond: 0));
1068        check("1234567", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_LONG));
1069        check("123456789", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_LONG));
1070        check("4x", &[internal_fixed(Nanosecond6NoDot)], Err(TOO_SHORT));
1071        check("     4", &[internal_fixed(Nanosecond6NoDot)], Err(INVALID));
1072        check(".42100", &[internal_fixed(Nanosecond6NoDot)], Err(INVALID));
1073
1074        check("", &[internal_fixed(Nanosecond9NoDot)], Err(TOO_SHORT));
1075        check(".", &[internal_fixed(Nanosecond9NoDot)], Err(TOO_SHORT));
1076        check("42195", &[internal_fixed(Nanosecond9NoDot)], Err(TOO_SHORT));
1077        check("12345678", &[internal_fixed(Nanosecond9NoDot)], Err(TOO_SHORT));
1078        check("421950803", &[internal_fixed(Nanosecond9NoDot)], parsed!(nanosecond: 421_950_803));
1079        check("000000003", &[internal_fixed(Nanosecond9NoDot)], parsed!(nanosecond: 3));
1080        check(
1081            "42195080354",
1082            &[internal_fixed(Nanosecond9NoDot), num(Second)],
1083            parsed!(nanosecond: 421_950_803, second: 54),
1084        ); // don't skip digits that come after the 9
1085        check("1234567890", &[internal_fixed(Nanosecond9NoDot)], Err(TOO_LONG));
1086        check("000000000", &[internal_fixed(Nanosecond9NoDot)], parsed!(nanosecond: 0));
1087        check("00000000x", &[internal_fixed(Nanosecond9NoDot)], Err(INVALID));
1088        check("        4", &[internal_fixed(Nanosecond9NoDot)], Err(INVALID));
1089        check(".42100000", &[internal_fixed(Nanosecond9NoDot)], Err(INVALID));
1090    }
1091
1092    #[test]
1093    fn test_parse_fixed_timezone_offset() {
1094        use crate::format::Fixed::*;
1095        use crate::format::InternalInternal::*;
1096        use crate::format::Item::Literal;
1097
1098        // TimezoneOffset
1099        check("1", &[fixed(TimezoneOffset)], Err(INVALID));
1100        check("12", &[fixed(TimezoneOffset)], Err(INVALID));
1101        check("123", &[fixed(TimezoneOffset)], Err(INVALID));
1102        check("1234", &[fixed(TimezoneOffset)], Err(INVALID));
1103        check("12345", &[fixed(TimezoneOffset)], Err(INVALID));
1104        check("123456", &[fixed(TimezoneOffset)], Err(INVALID));
1105        check("1234567", &[fixed(TimezoneOffset)], Err(INVALID));
1106        check("+1", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1107        check("+12", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1108        check("+123", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1109        check("+1234", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1110        check("+12345", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1111        check("+123456", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1112        check("+1234567", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1113        check("+12345678", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1114        check("+12:", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1115        check("+12:3", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1116        check("+12:34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1117        check("-12:34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1118        check("−12:34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1119        check("+12:34:", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1120        check("+12:34:5", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1121        check("+12:34:56", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1122        check("+12:34:56:", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1123        check("+12 34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1124        check("+12  34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1125        check("12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1126        check("12:34:56", &[fixed(TimezoneOffset)], Err(INVALID));
1127        check("+12::34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1128        check("+12: :34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1129        check("+12:::34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1130        check("+12::::34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1131        check("+12::34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1132        check("+12:34:56", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1133        check("+12:3456", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1134        check("+1234:56", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1135        check("+1234:567", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1136        check("+00:00", &[fixed(TimezoneOffset)], parsed!(offset: 0));
1137        check("-00:00", &[fixed(TimezoneOffset)], parsed!(offset: 0));
1138        check("−00:00", &[fixed(TimezoneOffset)], parsed!(offset: 0)); // MINUS SIGN (U+2212)
1139        check("+00:01", &[fixed(TimezoneOffset)], parsed!(offset: 60));
1140        check("-00:01", &[fixed(TimezoneOffset)], parsed!(offset: -60));
1141        check("+00:30", &[fixed(TimezoneOffset)], parsed!(offset: 1_800));
1142        check("-00:30", &[fixed(TimezoneOffset)], parsed!(offset: -1_800));
1143        check("+24:00", &[fixed(TimezoneOffset)], parsed!(offset: 86_400));
1144        check("-24:00", &[fixed(TimezoneOffset)], parsed!(offset: -86_400));
1145        check("−24:00", &[fixed(TimezoneOffset)], parsed!(offset: -86_400)); // MINUS SIGN (U+2212)
1146        check("+99:59", &[fixed(TimezoneOffset)], parsed!(offset: 359_940));
1147        check("-99:59", &[fixed(TimezoneOffset)], parsed!(offset: -359_940));
1148        check("+00:60", &[fixed(TimezoneOffset)], Err(OUT_OF_RANGE));
1149        check("+00:99", &[fixed(TimezoneOffset)], Err(OUT_OF_RANGE));
1150        check("#12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1151        check("+12:34 ", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1152        check("+12 34 ", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1153        check(" +12:34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1154        check(" -12:34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1155        check(" −12:34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1156        check("  +12:34", &[fixed(TimezoneOffset)], parsed!(offset: 45_240));
1157        check("  -12:34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1158        check("\t -12:34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1159        check("-12: 34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1160        check("-12 :34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1161        check("-12 : 34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1162        check("-12 :  34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1163        check("-12  : 34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1164        check("-12:  34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1165        check("-12  :34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1166        check("-12  :  34", &[fixed(TimezoneOffset)], parsed!(offset: -45_240));
1167        check("12:34 ", &[fixed(TimezoneOffset)], Err(INVALID));
1168        check(" 12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1169        check("", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1170        check("+", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1171        check(
1172            "+12345",
1173            &[fixed(TimezoneOffset), num(Numeric::Day)],
1174            parsed!(offset: 45_240, day: 5),
1175        );
1176        check(
1177            "+12:345",
1178            &[fixed(TimezoneOffset), num(Numeric::Day)],
1179            parsed!(offset: 45_240, day: 5),
1180        );
1181        check("+12:34:", &[fixed(TimezoneOffset), Literal(":")], parsed!(offset: 45_240));
1182        check("Z12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1183        check("X12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1184        check("Z+12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1185        check("X+12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1186        check("X−12:34", &[fixed(TimezoneOffset)], Err(INVALID)); // MINUS SIGN (U+2212)
1187        check("🤠+12:34", &[fixed(TimezoneOffset)], Err(INVALID));
1188        check("+12:34🤠", &[fixed(TimezoneOffset)], Err(TOO_LONG));
1189        check("+12:🤠34", &[fixed(TimezoneOffset)], Err(INVALID));
1190        check("+1234🤠", &[fixed(TimezoneOffset), Literal("🤠")], parsed!(offset: 45_240));
1191        check("-1234🤠", &[fixed(TimezoneOffset), Literal("🤠")], parsed!(offset: -45_240));
1192        check("−1234🤠", &[fixed(TimezoneOffset), Literal("🤠")], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1193        check("+12:34🤠", &[fixed(TimezoneOffset), Literal("🤠")], parsed!(offset: 45_240));
1194        check("-12:34🤠", &[fixed(TimezoneOffset), Literal("🤠")], parsed!(offset: -45_240));
1195        check("−12:34🤠", &[fixed(TimezoneOffset), Literal("🤠")], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1196        check("🤠+12:34", &[Literal("🤠"), fixed(TimezoneOffset)], parsed!(offset: 45_240));
1197        check("Z", &[fixed(TimezoneOffset)], Err(INVALID));
1198        check("A", &[fixed(TimezoneOffset)], Err(INVALID));
1199        check("PST", &[fixed(TimezoneOffset)], Err(INVALID));
1200        check("#Z", &[fixed(TimezoneOffset)], Err(INVALID));
1201        check(":Z", &[fixed(TimezoneOffset)], Err(INVALID));
1202        check("+Z", &[fixed(TimezoneOffset)], Err(TOO_SHORT));
1203        check("+:Z", &[fixed(TimezoneOffset)], Err(INVALID));
1204        check("+Z:", &[fixed(TimezoneOffset)], Err(INVALID));
1205        check("z", &[fixed(TimezoneOffset)], Err(INVALID));
1206        check(" :Z", &[fixed(TimezoneOffset)], Err(INVALID));
1207        check(" Z", &[fixed(TimezoneOffset)], Err(INVALID));
1208        check(" z", &[fixed(TimezoneOffset)], Err(INVALID));
1209
1210        // TimezoneOffsetColon
1211        check("1", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1212        check("12", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1213        check("123", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1214        check("1234", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1215        check("12345", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1216        check("123456", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1217        check("1234567", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1218        check("12345678", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1219        check("+1", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1220        check("+12", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1221        check("+123", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1222        check("+1234", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1223        check("-1234", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240));
1224        check("−1234", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1225        check("+12345", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1226        check("+123456", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1227        check("+1234567", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1228        check("+12345678", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1229        check("1:", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1230        check("12:", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1231        check("12:3", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1232        check("12:34", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1233        check("12:34:", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1234        check("12:34:5", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1235        check("12:34:56", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1236        check("+1:", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1237        check("+12:", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1238        check("+12:3", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1239        check("+12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1240        check("-12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240));
1241        check("−12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1242        check("+12:34:", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1243        check("+12:34:5", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1244        check("+12:34:56", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1245        check("+12:34:56:", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1246        check("+12:34:56:7", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1247        check("+12:34:56:78", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1248        check("+12:3456", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1249        check("+1234:56", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1250        check("−12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1251        check("−12 : 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1252        check("+12 :34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1253        check("+12: 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1254        check("+12 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1255        check("+12: 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1256        check("+12 :34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1257        check("+12 : 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1258        check("-12 : 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: -45_240));
1259        check("+12  : 34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1260        check("+12 :  34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1261        check("+12  :  34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1262        check("+12::34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1263        check("+12: :34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1264        check("+12:::34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1265        check("+12::::34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1266        check("+12::34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1267        check("#1234", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1268        check("#12:34", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1269        check("+12:34 ", &[fixed(TimezoneOffsetColon)], Err(TOO_LONG));
1270        check(" +12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1271        check("\t+12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1272        check("\t\t+12:34", &[fixed(TimezoneOffsetColon)], parsed!(offset: 45_240));
1273        check("12:34 ", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1274        check(" 12:34", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1275        check("", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1276        check("+", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1277        check(":", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1278        check(
1279            "+12345",
1280            &[fixed(TimezoneOffsetColon), num(Numeric::Day)],
1281            parsed!(offset: 45_240, day: 5),
1282        );
1283        check(
1284            "+12:345",
1285            &[fixed(TimezoneOffsetColon), num(Numeric::Day)],
1286            parsed!(offset: 45_240, day: 5),
1287        );
1288        check("+12:34:", &[fixed(TimezoneOffsetColon), Literal(":")], parsed!(offset: 45_240));
1289        check("Z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1290        check("A", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1291        check("PST", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1292        check("#Z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1293        check(":Z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1294        check("+Z", &[fixed(TimezoneOffsetColon)], Err(TOO_SHORT));
1295        check("+:Z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1296        check("+Z:", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1297        check("z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1298        check(" :Z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1299        check(" Z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1300        check(" z", &[fixed(TimezoneOffsetColon)], Err(INVALID));
1301        // testing `TimezoneOffsetColon` also tests same path as `TimezoneOffsetDoubleColon`
1302        // and `TimezoneOffsetTripleColon` for function `parse_internal`.
1303        // No need for separate tests for `TimezoneOffsetDoubleColon` and
1304        // `TimezoneOffsetTripleColon`.
1305
1306        // TimezoneOffsetZ
1307        check("1", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1308        check("12", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1309        check("123", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1310        check("1234", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1311        check("12345", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1312        check("123456", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1313        check("1234567", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1314        check("12345678", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1315        check("+1", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1316        check("+12", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1317        check("+123", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1318        check("+1234", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1319        check("-1234", &[fixed(TimezoneOffsetZ)], parsed!(offset: -45_240));
1320        check("−1234", &[fixed(TimezoneOffsetZ)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1321        check("+12345", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1322        check("+123456", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1323        check("+1234567", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1324        check("+12345678", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1325        check("1:", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1326        check("12:", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1327        check("12:3", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1328        check("12:34", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1329        check("12:34:", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1330        check("12:34:5", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1331        check("12:34:56", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1332        check("+1:", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1333        check("+12:", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1334        check("+12:3", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1335        check("+12:34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1336        check("-12:34", &[fixed(TimezoneOffsetZ)], parsed!(offset: -45_240));
1337        check("−12:34", &[fixed(TimezoneOffsetZ)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1338        check("+12:34:", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1339        check("+12:34:5", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1340        check("+12:34:56", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1341        check("+12:34:56:", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1342        check("+12:34:56:7", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1343        check("+12:34:56:78", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1344        check("+12::34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1345        check("+12:3456", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1346        check("+1234:56", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1347        check("+12 34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1348        check("+12  34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1349        check("+12: 34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1350        check("+12 :34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1351        check("+12 : 34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1352        check("+12  : 34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1353        check("+12 :  34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1354        check("+12  :  34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1355        check("12:34 ", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1356        check(" 12:34", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1357        check("+12:34 ", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1358        check("+12 34 ", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1359        check(" +12:34", &[fixed(TimezoneOffsetZ)], parsed!(offset: 45_240));
1360        check(
1361            "+12345",
1362            &[fixed(TimezoneOffsetZ), num(Numeric::Day)],
1363            parsed!(offset: 45_240, day: 5),
1364        );
1365        check(
1366            "+12:345",
1367            &[fixed(TimezoneOffsetZ), num(Numeric::Day)],
1368            parsed!(offset: 45_240, day: 5),
1369        );
1370        check("+12:34:", &[fixed(TimezoneOffsetZ), Literal(":")], parsed!(offset: 45_240));
1371        check("Z12:34", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1372        check("X12:34", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1373        check("Z", &[fixed(TimezoneOffsetZ)], parsed!(offset: 0));
1374        check("z", &[fixed(TimezoneOffsetZ)], parsed!(offset: 0));
1375        check(" Z", &[fixed(TimezoneOffsetZ)], parsed!(offset: 0));
1376        check(" z", &[fixed(TimezoneOffsetZ)], parsed!(offset: 0));
1377        check("\u{0363}Z", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1378        check("Z ", &[fixed(TimezoneOffsetZ)], Err(TOO_LONG));
1379        check("A", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1380        check("PST", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1381        check("#Z", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1382        check(":Z", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1383        check(":z", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1384        check("+Z", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1385        check("-Z", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1386        check("+A", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1387        check("+🙃", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1388        check("+Z:", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1389        check(" :Z", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1390        check(" +Z", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1391        check(" -Z", &[fixed(TimezoneOffsetZ)], Err(TOO_SHORT));
1392        check("+:Z", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1393        check("Y", &[fixed(TimezoneOffsetZ)], Err(INVALID));
1394        check("Zulu", &[fixed(TimezoneOffsetZ), Literal("ulu")], parsed!(offset: 0));
1395        check("zulu", &[fixed(TimezoneOffsetZ), Literal("ulu")], parsed!(offset: 0));
1396        check("+1234ulu", &[fixed(TimezoneOffsetZ), Literal("ulu")], parsed!(offset: 45_240));
1397        check("+12:34ulu", &[fixed(TimezoneOffsetZ), Literal("ulu")], parsed!(offset: 45_240));
1398        // Testing `TimezoneOffsetZ` also tests same path as `TimezoneOffsetColonZ`
1399        // in function `parse_internal`.
1400        // No need for separate tests for `TimezoneOffsetColonZ`.
1401
1402        // TimezoneOffsetPermissive
1403        check("1", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1404        check("12", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1405        check("123", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1406        check("1234", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1407        check("12345", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1408        check("123456", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1409        check("1234567", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1410        check("12345678", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1411        check("+1", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1412        check("+12", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 43_200));
1413        check("+123", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1414        check("+1234", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1415        check("-1234", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: -45_240));
1416        check("−1234", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1417        check("+12345", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1418        check("+123456", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1419        check("+1234567", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1420        check("+12345678", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1421        check("1:", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1422        check("12:", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1423        check("12:3", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1424        check("12:34", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1425        check("12:34:", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1426        check("12:34:5", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1427        check("12:34:56", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1428        check("+1:", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1429        check("+12:", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 43_200));
1430        check("+12:3", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1431        check("+12:34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1432        check("-12:34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: -45_240));
1433        check("−12:34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1434        check("+12:34:", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1435        check("+12:34:5", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1436        check("+12:34:56", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1437        check("+12:34:56:", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1438        check("+12:34:56:7", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1439        check("+12:34:56:78", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1440        check("+12 34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1441        check("+12  34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1442        check("+12 :34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1443        check("+12: 34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1444        check("+12 : 34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1445        check("+12  :34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1446        check("+12:  34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1447        check("+12  :  34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1448        check("+12::34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1449        check("+12 ::34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1450        check("+12: :34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1451        check("+12:: 34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1452        check("+12  ::34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1453        check("+12:  :34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1454        check("+12::  34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1455        check("+12:::34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1456        check("+12::::34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1457        check("12:34 ", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1458        check(" 12:34", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1459        check("+12:34 ", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1460        check(" +12:34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 45_240));
1461        check(" -12:34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: -45_240));
1462        check(" −12:34", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: -45_240)); // MINUS SIGN (U+2212)
1463        check(
1464            "+12345",
1465            &[internal_fixed(TimezoneOffsetPermissive), num(Numeric::Day)],
1466            parsed!(offset: 45_240, day: 5),
1467        );
1468        check(
1469            "+12:345",
1470            &[internal_fixed(TimezoneOffsetPermissive), num(Numeric::Day)],
1471            parsed!(offset: 45_240, day: 5),
1472        );
1473        check(
1474            "+12:34:",
1475            &[internal_fixed(TimezoneOffsetPermissive), Literal(":")],
1476            parsed!(offset: 45_240),
1477        );
1478        check("🤠+12:34", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1479        check("+12:34🤠", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1480        check("+12:🤠34", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1481        check(
1482            "+12:34🤠",
1483            &[internal_fixed(TimezoneOffsetPermissive), Literal("🤠")],
1484            parsed!(offset: 45_240),
1485        );
1486        check(
1487            "🤠+12:34",
1488            &[Literal("🤠"), internal_fixed(TimezoneOffsetPermissive)],
1489            parsed!(offset: 45_240),
1490        );
1491        check("Z", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 0));
1492        check("A", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1493        check("PST", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1494        check("z", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 0));
1495        check(" Z", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 0));
1496        check(" z", &[internal_fixed(TimezoneOffsetPermissive)], parsed!(offset: 0));
1497        check("Z ", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_LONG));
1498        check("#Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1499        check(":Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1500        check(":z", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1501        check("+Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1502        check("-Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1503        check("+A", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1504        check("+PST", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1505        check("+🙃", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1506        check("+Z:", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1507        check(" :Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1508        check(" +Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1509        check(" -Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(TOO_SHORT));
1510        check("+:Z", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1511        check("Y", &[internal_fixed(TimezoneOffsetPermissive)], Err(INVALID));
1512
1513        // TimezoneName
1514        check("CEST", &[fixed(TimezoneName)], parsed!());
1515        check("cest", &[fixed(TimezoneName)], parsed!()); // lowercase
1516        check("XXXXXXXX", &[fixed(TimezoneName)], parsed!()); // not a real timezone name
1517        check("!!!!", &[fixed(TimezoneName)], parsed!()); // not a real timezone name!
1518        check("CEST 5", &[fixed(TimezoneName), Literal(" "), num(Numeric::Day)], parsed!(day: 5));
1519        check("CEST ", &[fixed(TimezoneName)], Err(TOO_LONG));
1520        check(" CEST", &[fixed(TimezoneName)], Err(TOO_LONG));
1521        check("CE ST", &[fixed(TimezoneName)], Err(TOO_LONG));
1522    }
1523
1524    #[test]
1525    #[rustfmt::skip]
1526    fn test_parse_practical_examples() {
1527        use crate::format::InternalInternal::*;
1528        use crate::format::Item::{Literal, Space};
1529        use crate::format::Numeric::*;
1530
1531        // some practical examples
1532        check(
1533            "2015-02-04T14:37:05+09:00",
1534            &[
1535                num(Year), Literal("-"), num(Month), Literal("-"), num(Day), Literal("T"),
1536                num(Hour), Literal(":"), num(Minute), Literal(":"), num(Second),
1537                fixed(Fixed::TimezoneOffset),
1538            ],
1539            parsed!(
1540                year: 2015, month: 2, day: 4, hour_div_12: 1, hour_mod_12: 2, minute: 37,
1541                second: 5, offset: 32400
1542            ),
1543        );
1544        check(
1545            "2015-02-04T14:37:05-09:00",
1546            &[
1547                num(Year), Literal("-"), num(Month), Literal("-"), num(Day), Literal("T"),
1548                num(Hour), Literal(":"), num(Minute), Literal(":"), num(Second),
1549                fixed(Fixed::TimezoneOffset),
1550            ],
1551            parsed!(
1552                year: 2015, month: 2, day: 4, hour_div_12: 1, hour_mod_12: 2, minute: 37,
1553                second: 5, offset: -32400
1554            ),
1555        );
1556        check(
1557            "2015-02-04T14:37:05−09:00", // timezone offset using MINUS SIGN (U+2212)
1558            &[
1559                num(Year), Literal("-"), num(Month), Literal("-"), num(Day), Literal("T"),
1560                num(Hour), Literal(":"), num(Minute), Literal(":"), num(Second),
1561                fixed(Fixed::TimezoneOffset)
1562            ],
1563            parsed!(
1564                year: 2015, month: 2, day: 4, hour_div_12: 1, hour_mod_12: 2, minute: 37,
1565                second: 5, offset: -32400
1566            ),
1567        );
1568        check(
1569            "20150204143705567",
1570            &[
1571                num(Year), num(Month), num(Day), num(Hour), num(Minute), num(Second),
1572                internal_fixed(Nanosecond3NoDot)
1573            ],
1574            parsed!(
1575                year: 2015, month: 2, day: 4, hour_div_12: 1, hour_mod_12: 2, minute: 37,
1576                second: 5, nanosecond: 567000000
1577            ),
1578        );
1579        check(
1580            "Mon, 10 Jun 2013 09:32:37 GMT",
1581            &[
1582                fixed(Fixed::ShortWeekdayName), Literal(","), Space(" "), num(Day), Space(" "),
1583                fixed(Fixed::ShortMonthName), Space(" "), num(Year), Space(" "), num(Hour),
1584                Literal(":"), num(Minute), Literal(":"), num(Second), Space(" "), Literal("GMT")
1585            ],
1586            parsed!(
1587                year: 2013, month: 6, day: 10, weekday: Weekday::Mon,
1588                hour_div_12: 0, hour_mod_12: 9, minute: 32, second: 37
1589            ),
1590        );
1591        check(
1592            "🤠Mon, 10 Jun🤠2013 09:32:37  GMT🤠",
1593            &[
1594                Literal("🤠"), fixed(Fixed::ShortWeekdayName), Literal(","), Space(" "), num(Day),
1595                Space(" "), fixed(Fixed::ShortMonthName), Literal("🤠"), num(Year), Space(" "),
1596                num(Hour), Literal(":"), num(Minute), Literal(":"), num(Second), Space("  "),
1597                Literal("GMT"), Literal("🤠")
1598            ],
1599            parsed!(
1600                year: 2013, month: 6, day: 10, weekday: Weekday::Mon,
1601                hour_div_12: 0, hour_mod_12: 9, minute: 32, second: 37
1602            ),
1603        );
1604        check(
1605            "Sun Aug 02 13:39:15 CEST 2020",
1606            &[
1607                fixed(Fixed::ShortWeekdayName), Space(" "), fixed(Fixed::ShortMonthName),
1608                Space(" "), num(Day), Space(" "), num(Hour), Literal(":"), num(Minute),
1609                Literal(":"), num(Second), Space(" "), fixed(Fixed::TimezoneName), Space(" "),
1610                num(Year)
1611            ],
1612            parsed!(
1613                year: 2020, month: 8, day: 2, weekday: Weekday::Sun,
1614                hour_div_12: 1, hour_mod_12: 1, minute: 39, second: 15
1615            ),
1616        );
1617        check(
1618            "20060102150405",
1619            &[num(Year), num(Month), num(Day), num(Hour), num(Minute), num(Second)],
1620            parsed!(
1621                year: 2006, month: 1, day: 2, hour_div_12: 1, hour_mod_12: 3, minute: 4, second: 5
1622            ),
1623        );
1624        check(
1625            "3:14PM",
1626            &[num(Hour12), Literal(":"), num(Minute), fixed(Fixed::LowerAmPm)],
1627            parsed!(hour_div_12: 1, hour_mod_12: 3, minute: 14),
1628        );
1629        check(
1630            "12345678901234.56789",
1631            &[num(Timestamp), Literal("."), num(Nanosecond)],
1632            parsed!(nanosecond: 56_789, timestamp: 12_345_678_901_234),
1633        );
1634        check(
1635            "12345678901234.56789",
1636            &[num(Timestamp), fixed(Fixed::Nanosecond)],
1637            parsed!(nanosecond: 567_890_000, timestamp: 12_345_678_901_234),
1638        );
1639
1640        // docstring examples from `impl str::FromStr`
1641        check(
1642            "2000-01-02T03:04:05Z",
1643            &[
1644                num(Year), Literal("-"), num(Month), Literal("-"), num(Day), Literal("T"),
1645                num(Hour), Literal(":"), num(Minute), Literal(":"), num(Second),
1646                internal_fixed(TimezoneOffsetPermissive)
1647            ],
1648            parsed!(
1649                year: 2000, month: 1, day: 2, hour_div_12: 0, hour_mod_12: 3, minute: 4, second: 5,
1650                offset: 0
1651            ),
1652        );
1653        check(
1654            "2000-01-02 03:04:05Z",
1655            &[
1656                num(Year), Literal("-"), num(Month), Literal("-"), num(Day), Space(" "),
1657                num(Hour), Literal(":"), num(Minute), Literal(":"), num(Second),
1658                internal_fixed(TimezoneOffsetPermissive)
1659            ],
1660            parsed!(
1661                year: 2000, month: 1, day: 2, hour_div_12: 0, hour_mod_12: 3, minute: 4, second: 5,
1662                offset: 0
1663            ),
1664        );
1665    }
1666
1667    #[track_caller]
1668    fn parses(s: &str, items: &[Item]) {
1669        let mut parsed = Parsed::new();
1670        assert!(parse(&mut parsed, s, items.iter()).is_ok());
1671    }
1672
1673    #[track_caller]
1674    fn check(s: &str, items: &[Item], expected: ParseResult<Parsed>) {
1675        let mut parsed = Parsed::new();
1676        let result = parse(&mut parsed, s, items.iter());
1677        let parsed = result.map(|_| parsed);
1678        assert_eq!(parsed, expected);
1679    }
1680
1681    #[test]
1682    fn test_rfc2822() {
1683        let ymd_hmsn = |y, m, d, h, n, s, nano, off| {
1684            FixedOffset::east_opt(off * 60 * 60)
1685                .unwrap()
1686                .with_ymd_and_hms(y, m, d, h, n, s)
1687                .unwrap()
1688                .with_nanosecond(nano)
1689                .unwrap()
1690        };
1691
1692        // Test data - (input, Ok(expected result) or Err(error code))
1693        let testdates = [
1694            ("Tue, 20 Jan 2015 17:35:20 -0800", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // normal case
1695            ("Fri,  2 Jan 2015 17:35:20 -0800", Ok(ymd_hmsn(2015, 1, 2, 17, 35, 20, 0, -8))), // folding whitespace
1696            ("Fri, 02 Jan 2015 17:35:20 -0800", Ok(ymd_hmsn(2015, 1, 2, 17, 35, 20, 0, -8))), // leading zero
1697            ("Tue, 20 Jan 2015 17:35:20 -0800 (UTC)", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // trailing comment
1698            (
1699                r"Tue, 20 Jan 2015 17:35:20 -0800 ( (UTC ) (\( (a)\(( \t ) ) \\( \) ))",
1700                Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8)),
1701            ), // complex trailing comment
1702            (r"Tue, 20 Jan 2015 17:35:20 -0800 (UTC\)", Err(TOO_LONG)), // incorrect comment, not enough closing parentheses
1703            (
1704                "Tue, 20 Jan 2015 17:35:20 -0800 (UTC)\t \r\n(Anothercomment)",
1705                Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8)),
1706            ), // multiple comments
1707            ("Tue, 20 Jan 2015 17:35:20 -0800 (UTC) ", Err(TOO_LONG)), // trailing whitespace after comment
1708            ("20 Jan 2015 17:35:20 -0800", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // no day of week
1709            ("20 JAN 2015 17:35:20 -0800", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // upper case month
1710            ("Tue, 20 Jan 2015 17:35 -0800", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 0, 0, -8))), // no second
1711            ("11 Sep 2001 09:45:00 +0000", Ok(ymd_hmsn(2001, 9, 11, 9, 45, 0, 0, 0))),
1712            ("11 Sep 2001 09:45:00 EST", Ok(ymd_hmsn(2001, 9, 11, 9, 45, 0, 0, -5))),
1713            ("11 Sep 2001 09:45:00 GMT", Ok(ymd_hmsn(2001, 9, 11, 9, 45, 0, 0, 0))),
1714            ("30 Feb 2015 17:35:20 -0800", Err(OUT_OF_RANGE)), // bad day of month
1715            ("Tue, 20 Jan 2015", Err(TOO_SHORT)),              // omitted fields
1716            ("Tue, 20 Avr 2015 17:35:20 -0800", Err(INVALID)), // bad month name
1717            ("Tue, 20 Jan 2015 25:35:20 -0800", Err(OUT_OF_RANGE)), // bad hour
1718            ("Tue, 20 Jan 2015 7:35:20 -0800", Err(INVALID)),  // bad # of digits in hour
1719            ("Tue, 20 Jan 2015 17:65:20 -0800", Err(OUT_OF_RANGE)), // bad minute
1720            ("Tue, 20 Jan 2015 17:35:90 -0800", Err(OUT_OF_RANGE)), // bad second
1721            ("Tue, 20 Jan 2015 17:35:20 -0890", Err(OUT_OF_RANGE)), // bad offset
1722            ("6 Jun 1944 04:00:00Z", Err(INVALID)),            // bad offset (zulu not allowed)
1723            // named timezones that have specific timezone offsets
1724            // see https://www.rfc-editor.org/rfc/rfc2822#section-4.3
1725            ("Tue, 20 Jan 2015 17:35:20 GMT", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1726            ("Tue, 20 Jan 2015 17:35:20 UT", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1727            ("Tue, 20 Jan 2015 17:35:20 ut", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1728            ("Tue, 20 Jan 2015 17:35:20 EDT", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -4))),
1729            ("Tue, 20 Jan 2015 17:35:20 EST", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -5))),
1730            ("Tue, 20 Jan 2015 17:35:20 CDT", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -5))),
1731            ("Tue, 20 Jan 2015 17:35:20 CST", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -6))),
1732            ("Tue, 20 Jan 2015 17:35:20 MDT", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -6))),
1733            ("Tue, 20 Jan 2015 17:35:20 MST", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -7))),
1734            ("Tue, 20 Jan 2015 17:35:20 PDT", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -7))),
1735            ("Tue, 20 Jan 2015 17:35:20 PST", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))),
1736            ("Tue, 20 Jan 2015 17:35:20 pst", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))),
1737            // named single-letter military timezones must fallback to +0000
1738            ("Tue, 20 Jan 2015 17:35:20 Z", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1739            ("Tue, 20 Jan 2015 17:35:20 A", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1740            ("Tue, 20 Jan 2015 17:35:20 a", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1741            ("Tue, 20 Jan 2015 17:35:20 K", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1742            ("Tue, 20 Jan 2015 17:35:20 k", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, 0))),
1743            // named single-letter timezone "J" is specifically not valid
1744            ("Tue, 20 Jan 2015 17:35:20 J", Err(INVALID)),
1745            ("Tue, 20 Jan 2015 17:35:20 -0890", Err(OUT_OF_RANGE)), // bad offset minutes
1746            ("Tue, 20 Jan 2015 17:35:20Z", Err(INVALID)),           // bad offset: zulu not allowed
1747            ("Tue, 20 Jan 2015 17:35:20 Zulu", Err(INVALID)),       // bad offset: zulu not allowed
1748            ("Tue, 20 Jan 2015 17:35:20 ZULU", Err(INVALID)),       // bad offset: zulu not allowed
1749            ("Tue, 20 Jan 2015 17:35:20 −0800", Err(INVALID)), // bad offset: timezone offset using MINUS SIGN (U+2212), not specified for RFC 2822
1750            ("Tue, 20 Jan 2015 17:35:20 0800", Err(INVALID)),  // missing offset sign
1751            ("Tue, 20 Jan 2015 17:35:20 HAS", Err(INVALID)),   // bad named timezone
1752            ("Tue, 20 Jan 2015😈17:35:20 -0800", Err(INVALID)), // bad character!
1753        ];
1754
1755        fn rfc2822_to_datetime(date: &str) -> ParseResult<DateTime<FixedOffset>> {
1756            let mut parsed = Parsed::new();
1757            parse(&mut parsed, date, [Item::Fixed(Fixed::RFC2822)].iter())?;
1758            parsed.to_datetime()
1759        }
1760
1761        // Test against test data above
1762        for &(date, checkdate) in testdates.iter() {
1763            #[cfg(feature = "std")]
1764            eprintln!("Test input: {date:?}\n    Expect: {checkdate:?}");
1765            let dt = rfc2822_to_datetime(date); // parse a date
1766            if dt != checkdate {
1767                // check for expected result
1768                panic!(
1769                    "Date conversion failed for {date}\nReceived: {dt:?}\nExpected: {checkdate:?}"
1770                );
1771            }
1772        }
1773    }
1774
1775    #[test]
1776    fn parse_rfc850() {
1777        static RFC850_FMT: &str = "%A, %d-%b-%y %T GMT";
1778
1779        let dt = Utc.with_ymd_and_hms(1994, 11, 6, 8, 49, 37).unwrap();
1780
1781        // Check that the format is what we expect
1782        #[cfg(feature = "alloc")]
1783        assert_eq!(dt.format(RFC850_FMT).to_string(), "Sunday, 06-Nov-94 08:49:37 GMT");
1784
1785        // Check that it parses correctly
1786        assert_eq!(
1787            NaiveDateTime::parse_from_str("Sunday, 06-Nov-94 08:49:37 GMT", RFC850_FMT),
1788            Ok(dt.naive_utc())
1789        );
1790
1791        // Check that the rest of the weekdays parse correctly (this test originally failed because
1792        // Sunday parsed incorrectly).
1793        let testdates = [
1794            (
1795                Utc.with_ymd_and_hms(1994, 11, 7, 8, 49, 37).unwrap(),
1796                "Monday, 07-Nov-94 08:49:37 GMT",
1797            ),
1798            (
1799                Utc.with_ymd_and_hms(1994, 11, 8, 8, 49, 37).unwrap(),
1800                "Tuesday, 08-Nov-94 08:49:37 GMT",
1801            ),
1802            (
1803                Utc.with_ymd_and_hms(1994, 11, 9, 8, 49, 37).unwrap(),
1804                "Wednesday, 09-Nov-94 08:49:37 GMT",
1805            ),
1806            (
1807                Utc.with_ymd_and_hms(1994, 11, 10, 8, 49, 37).unwrap(),
1808                "Thursday, 10-Nov-94 08:49:37 GMT",
1809            ),
1810            (
1811                Utc.with_ymd_and_hms(1994, 11, 11, 8, 49, 37).unwrap(),
1812                "Friday, 11-Nov-94 08:49:37 GMT",
1813            ),
1814            (
1815                Utc.with_ymd_and_hms(1994, 11, 12, 8, 49, 37).unwrap(),
1816                "Saturday, 12-Nov-94 08:49:37 GMT",
1817            ),
1818        ];
1819
1820        for val in &testdates {
1821            assert_eq!(NaiveDateTime::parse_from_str(val.1, RFC850_FMT), Ok(val.0.naive_utc()));
1822        }
1823
1824        let test_dates_fail = [
1825            "Saturday, 12-Nov-94 08:49:37",
1826            "Saturday, 12-Nov-94 08:49:37 Z",
1827            "Saturday, 12-Nov-94 08:49:37 GMTTTT",
1828            "Saturday, 12-Nov-94 08:49:37 gmt",
1829            "Saturday, 12-Nov-94 08:49:37 +08:00",
1830            "Caturday, 12-Nov-94 08:49:37 GMT",
1831            "Saturday, 99-Nov-94 08:49:37 GMT",
1832            "Saturday, 12-Nov-2000 08:49:37 GMT",
1833            "Saturday, 12-Mop-94 08:49:37 GMT",
1834            "Saturday, 12-Nov-94 28:49:37 GMT",
1835            "Saturday, 12-Nov-94 08:99:37 GMT",
1836            "Saturday, 12-Nov-94 08:49:99 GMT",
1837        ];
1838
1839        for val in &test_dates_fail {
1840            assert!(NaiveDateTime::parse_from_str(val, RFC850_FMT).is_err());
1841        }
1842    }
1843
1844    #[test]
1845    fn test_rfc3339() {
1846        let ymd_hmsn = |y, m, d, h, n, s, nano, off| {
1847            FixedOffset::east_opt(off * 60 * 60)
1848                .unwrap()
1849                .with_ymd_and_hms(y, m, d, h, n, s)
1850                .unwrap()
1851                .with_nanosecond(nano)
1852                .unwrap()
1853        };
1854
1855        // Test data - (input, Ok(expected result) or Err(error code))
1856        let testdates = [
1857            ("2015-01-20T17:35:20-08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // normal case
1858            ("2015-01-20T17:35:20−08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // normal case with MINUS SIGN (U+2212)
1859            ("1944-06-06T04:04:00Z", Ok(ymd_hmsn(1944, 6, 6, 4, 4, 0, 0, 0))),           // D-day
1860            ("2001-09-11T09:45:00-08:00", Ok(ymd_hmsn(2001, 9, 11, 9, 45, 0, 0, -8))),
1861            ("2015-01-20T17:35:20.001-08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 1_000_000, -8))),
1862            ("2015-01-20T17:35:20.001−08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 1_000_000, -8))), // with MINUS SIGN (U+2212)
1863            ("2015-01-20T17:35:20.000031-08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 31_000, -8))),
1864            ("2015-01-20T17:35:20.000000004-08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 4, -8))),
1865            ("2015-01-20T17:35:20.000000004−08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 4, -8))), // with MINUS SIGN (U+2212)
1866            (
1867                "2015-01-20T17:35:20.000000000452-08:00",
1868                Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8)),
1869            ), // too small
1870            (
1871                "2015-01-20T17:35:20.000000000452−08:00",
1872                Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8)),
1873            ), // too small with MINUS SIGN (U+2212)
1874            ("2023-11-05T01:30:00-04:00", Ok(ymd_hmsn(2023, 11, 5, 1, 30, 0, 0, -4))), // ambiguous timestamp
1875            ("2015-01-20 17:35:20-08:00", Ok(ymd_hmsn(2015, 1, 20, 17, 35, 20, 0, -8))), // without 'T'
1876            ("2015-01-20_17:35:20-08:00", Err(INVALID)), // wrong date time separator
1877            ("2015/01/20T17:35:20.001-08:00", Err(INVALID)), // wrong separator char YM
1878            ("2015-01/20T17:35:20.001-08:00", Err(INVALID)), // wrong separator char MD
1879            ("2015-01-20T17-35-20.001-08:00", Err(INVALID)), // wrong separator char HM
1880            ("2015-01-20T17-35:20.001-08:00", Err(INVALID)), // wrong separator char MS
1881            ("-01-20T17:35:20-08:00", Err(INVALID)),     // missing year
1882            ("99-01-20T17:35:20-08:00", Err(INVALID)),   // bad year format
1883            ("99999-01-20T17:35:20-08:00", Err(INVALID)), // bad year value
1884            ("-2000-01-20T17:35:20-08:00", Err(INVALID)), // bad year value
1885            ("2015-00-30T17:35:20-08:00", Err(OUT_OF_RANGE)), // bad month value
1886            ("2015-02-30T17:35:20-08:00", Err(OUT_OF_RANGE)), // bad day of month value
1887            ("2015-01-20T25:35:20-08:00", Err(OUT_OF_RANGE)), // bad hour value
1888            ("2015-01-20T17:65:20-08:00", Err(OUT_OF_RANGE)), // bad minute value
1889            ("2015-01-20T17:35:90-08:00", Err(OUT_OF_RANGE)), // bad second value
1890            ("2015-01-20T17:35:20-24:00", Err(OUT_OF_RANGE)), // bad offset value
1891            ("15-01-20T17:35:20-08:00", Err(INVALID)),   // bad year format
1892            ("15-01-20T17:35:20-08:00:00", Err(INVALID)), // bad year format, bad offset format
1893            ("2015-01-20T17:35:2008:00", Err(INVALID)),  // missing offset sign
1894            ("2015-01-20T17:35:20 08:00", Err(INVALID)), // missing offset sign
1895            ("2015-01-20T17:35:20Zulu", Err(TOO_LONG)),  // bad offset format
1896            ("2015-01-20T17:35:20 Zulu", Err(INVALID)),  // bad offset format
1897            ("2015-01-20T17:35:20GMT", Err(INVALID)),    // bad offset format
1898            ("2015-01-20T17:35:20 GMT", Err(INVALID)),   // bad offset format
1899            ("2015-01-20T17:35:20+GMT", Err(INVALID)),   // bad offset format
1900            ("2015-01-20T17:35:20++08:00", Err(INVALID)), // bad offset format
1901            ("2015-01-20T17:35:20--08:00", Err(INVALID)), // bad offset format
1902            ("2015-01-20T17:35:20−−08:00", Err(INVALID)), // bad offset format with MINUS SIGN (U+2212)
1903            ("2015-01-20T17:35:20±08:00", Err(INVALID)),  // bad offset sign
1904            ("2015-01-20T17:35:20-08-00", Err(INVALID)),  // bad offset separator
1905            ("2015-01-20T17:35:20-08;00", Err(INVALID)),  // bad offset separator
1906            ("2015-01-20T17:35:20-0800", Err(INVALID)),   // bad offset separator
1907            ("2015-01-20T17:35:20-08:0", Err(TOO_SHORT)), // bad offset minutes
1908            ("2015-01-20T17:35:20-08:AA", Err(INVALID)),  // bad offset minutes
1909            ("2015-01-20T17:35:20-08:ZZ", Err(INVALID)),  // bad offset minutes
1910            ("2015-01-20T17:35:20.001-08 : 00", Err(INVALID)), // bad offset separator
1911            ("2015-01-20T17:35:20-08:00:00", Err(TOO_LONG)), // bad offset format
1912            ("2015-01-20T17:35:20+08:", Err(TOO_SHORT)),  // bad offset format
1913            ("2015-01-20T17:35:20-08:", Err(TOO_SHORT)),  // bad offset format
1914            ("2015-01-20T17:35:20−08:", Err(TOO_SHORT)), // bad offset format with MINUS SIGN (U+2212)
1915            ("2015-01-20T17:35:20-08", Err(TOO_SHORT)),  // bad offset format
1916            ("2015-01-20T", Err(TOO_SHORT)),             // missing HMS
1917            ("2015-01-20T00:00:1", Err(TOO_SHORT)),      // missing complete S
1918            ("2015-01-20T00:00:1-08:00", Err(INVALID)),  // missing complete S
1919        ];
1920
1921        // Test against test data above
1922        for &(date, checkdate) in testdates.iter() {
1923            let dt = DateTime::<FixedOffset>::parse_from_rfc3339(date);
1924            if dt != checkdate {
1925                // check for expected result
1926                panic!(
1927                    "Date conversion failed for {date}\nReceived: {dt:?}\nExpected: {checkdate:?}"
1928                );
1929            }
1930        }
1931    }
1932
1933    #[test]
1934    fn test_issue_1010() {
1935        let dt = crate::NaiveDateTime::parse_from_str(
1936            "\u{c}SUN\u{e}\u{3000}\0m@J\u{3000}\0\u{3000}\0m\u{c}!\u{c}\u{b}\u{c}\u{c}\u{c}\u{c}%A\u{c}\u{b}\0SU\u{c}\u{c}",
1937            "\u{c}\u{c}%A\u{c}\u{b}\0SUN\u{c}\u{c}\u{c}SUNN\u{c}\u{c}\u{c}SUN\u{c}\u{c}!\u{c}\u{b}\u{c}\u{c}\u{c}\u{c}%A\u{c}\u{b}%a",
1938        );
1939        assert_eq!(dt, Err(ParseError(ParseErrorKind::Invalid)));
1940    }
1941}
chrono/format/parse.rs

chrono/format/
parse.rs
