dateparser 0.3.1

#![allow(deprecated)]
//! A rust library for parsing date strings in commonly used formats. Parsed date will be returned
//! as `chrono`'s `DateTime<Utc>`.
//!
//! # Quick Start
//!
//! ```
//! use chrono::prelude::*;
//! use dateparser::parse;
//! use std::error::Error;
//!
//! fn main() -> Result<(), Box<dyn Error>> {
//!     assert_eq!(
//!         parse("6:15pm UTC")?,
//!         Utc::now().date().and_time(
//!             NaiveTime::from_hms(18, 15, 0),
//!         ).unwrap(),
//!     );
//!     Ok(())
//! }
//! ```
//!
//! Use `str`'s `parse` method:
//!
//! ```
//! use chrono::prelude::*;
//! use dateparser::DateTimeUtc;
//! use std::error::Error;
//!
//! fn main() -> Result<(), Box<dyn Error>> {
//!     assert_eq!(
//!         "2021-05-14 18:51 PDT".parse::<DateTimeUtc>()?.0,
//!         Utc.ymd(2021, 5, 15).and_hms(1, 51, 0),
//!     );
//!     Ok(())
//! }
//! ```
//!
//! Parse using a custom timezone offset for a datetime string that doesn't come with a specific
//! timezone:
//!
//! ```
//! use dateparser::parse_with_timezone;
//! use chrono::offset::Utc;
//! use std::error::Error;
//!
//! fn main() -> Result<(), Box<dyn Error>> {
//!     let parsed_in_utc = parse_with_timezone("6:15pm", &Utc)?;
//!     assert_eq!(
//!         parsed_in_utc,
//!         Utc::now().date().and_hms(18, 15, 0),
//!     );
//!     Ok(())
//! }
//! ```
//!
//! ## Accepted date formats
//!
//! ```
//! use dateparser::DateTimeUtc;
//!
//! let accepted = vec![
//!     // unix timestamp
//!     "1511648546",
//!     "1620021848429",
//!     "1620024872717915000",
//!     // rfc3339
//!     "2021-05-01T01:17:02.604456Z",
//!     "2017-11-25T22:34:50Z",
//!     // rfc2822
//!     "Wed, 02 Jun 2021 06:31:39 GMT",
//!     // postgres timestamp yyyy-mm-dd hh:mm:ss z
//!     "2019-11-29 08:08-08",
//!     "2019-11-29 08:08:05-08",
//!     "2021-05-02 23:31:36.0741-07",
//!     "2021-05-02 23:31:39.12689-07",
//!     "2019-11-29 08:15:47.624504-08",
//!     "2017-07-19 03:21:51+00:00",
//!     // yyyy-mm-dd hh:mm:ss
//!     "2014-04-26 05:24:37 PM",
//!     "2021-04-30 21:14",
//!     "2021-04-30 21:14:10",
//!     "2021-04-30 21:14:10.052282",
//!     "2014-04-26 17:24:37.123",
//!     "2014-04-26 17:24:37.3186369",
//!     "2012-08-03 18:31:59.257000000",
//!     // yyyy-mm-dd hh:mm:ss z
//!     "2017-11-25 13:31:15 PST",
//!     "2017-11-25 13:31 PST",
//!     "2014-12-16 06:20:00 UTC",
//!     "2014-12-16 06:20:00 GMT",
//!     "2014-04-26 13:13:43 +0800",
//!     "2014-04-26 13:13:44 +09:00",
//!     "2012-08-03 18:31:59.257000000 +0000",
//!     "2015-09-30 18:48:56.35272715 UTC",
//!     // yyyy-mm-dd
//!     "2021-02-21",
//!     // yyyy-mm-dd z
//!     "2021-02-21 PST",
//!     "2021-02-21 UTC",
//!     "2020-07-20+08:00",
//!     // hh:mm:ss
//!     "01:06:06",
//!     "4:00pm",
//!     "6:00 AM",
//!     // hh:mm:ss z
//!     "01:06:06 PST",
//!     "4:00pm PST",
//!     "6:00 AM PST",
//!     "6:00pm UTC",
//!     // Mon dd hh:mm:ss
//!     "May 6 at 9:24 PM",
//!     "May 27 02:45:27",
//!     // Mon dd, yyyy, hh:mm:ss
//!     "May 8, 2009 5:57:51 PM",
//!     "September 17, 2012 10:09am",
//!     "September 17, 2012, 10:10:09",
//!     // Mon dd, yyyy hh:mm:ss z
//!     "May 02, 2021 15:51:31 UTC",
//!     "May 02, 2021 15:51 UTC",
//!     "May 26, 2021, 12:49 AM PDT",
//!     "September 17, 2012 at 10:09am PST",
//!     // yyyy-mon-dd
//!     "2021-Feb-21",
//!     // Mon dd, yyyy
//!     "May 25, 2021",
//!     "oct 7, 1970",
//!     "oct 7, 70",
//!     "oct. 7, 1970",
//!     "oct. 7, 70",
//!     "October 7, 1970",
//!     // dd Mon yyyy hh:mm:ss
//!     "12 Feb 2006, 19:17",
//!     "12 Feb 2006 19:17",
//!     "14 May 2019 19:11:40.164",
//!     // dd Mon yyyy
//!     "7 oct 70",
//!     "7 oct 1970",
//!     "03 February 2013",
//!     "1 July 2013",
//!     // mm/dd/yyyy hh:mm:ss
//!     "4/8/2014 22:05",
//!     "04/08/2014 22:05",
//!     "4/8/14 22:05",
//!     "04/2/2014 03:00:51",
//!     "8/8/1965 12:00:00 AM",
//!     "8/8/1965 01:00:01 PM",
//!     "8/8/1965 01:00 PM",
//!     "8/8/1965 1:00 PM",
//!     "8/8/1965 12:00 AM",
//!     "4/02/2014 03:00:51",
//!     "03/19/2012 10:11:59",
//!     "03/19/2012 10:11:59.3186369",
//!     // mm/dd/yyyy
//!     "3/31/2014",
//!     "03/31/2014",
//!     "08/21/71",
//!     "8/1/71",
//!     // yyyy/mm/dd hh:mm:ss
//!     "2014/4/8 22:05",
//!     "2014/04/08 22:05",
//!     "2014/04/2 03:00:51",
//!     "2014/4/02 03:00:51",
//!     "2012/03/19 10:11:59",
//!     "2012/03/19 10:11:59.3186369",
//!     // yyyy/mm/dd
//!     "2014/3/31",
//!     "2014/03/31",
//!     // mm.dd.yyyy
//!     "3.31.2014",
//!     "03.31.2014",
//!     "08.21.71",
//!     // yyyy.mm.dd
//!     "2014.03.29",
//!     "2014.03",
//!     // yymmdd hh:mm:ss mysql log
//!     "171113 14:14:20",
//!     // chinese yyyy mm dd hh mm ss
//!     "2014年04月08日11时25分18秒",
//!     // chinese yyyy mm dd
//!     "2014年04月08日",
//! ];
//!
//! for date_str in accepted {
//!     let result = date_str.parse::<DateTimeUtc>();
//!     assert!(result.is_ok())
//! }
//! ```

/// Datetime string parser
///
/// ```
/// use chrono::prelude::*;
/// use dateparser::datetime::Parse;
/// use std::error::Error;
///
/// fn main() -> Result<(), Box<dyn Error>> {
///     let parse_with_local = Parse::new(&Local, None);
///     assert_eq!(
///         parse_with_local.parse("2021-06-05 06:19 PM")?,
///         Local.ymd(2021, 6, 5).and_hms(18, 19, 0).with_timezone(&Utc),
///     );
///
///     let parse_with_utc = Parse::new(&Utc, None);
///     assert_eq!(
///         parse_with_utc.parse("2021-06-05 06:19 PM")?,
///         Utc.ymd(2021, 6, 5).and_hms(18, 19, 0),
///     );
///
///     Ok(())
/// }
/// ```
pub mod datetime;

/// Timezone offset string parser
///
/// ```
/// use chrono::prelude::*;
/// use dateparser::timezone::parse;
/// use std::error::Error;
///
/// fn main() -> Result<(), Box<dyn Error>> {
///     assert_eq!(parse("-0800")?, FixedOffset::west(8 * 3600));
///     assert_eq!(parse("+10:00")?, FixedOffset::east(10 * 3600));
///     assert_eq!(parse("PST")?, FixedOffset::west(8 * 3600));
///     assert_eq!(parse("PDT")?, FixedOffset::west(7 * 3600));
///     assert_eq!(parse("UTC")?, FixedOffset::west(0));
///     assert_eq!(parse("GMT")?, FixedOffset::west(0));
///
///     Ok(())
/// }
/// ```
pub mod timezone;

use crate::datetime::Parse;
use anyhow::{Error, Result};
use chrono::prelude::*;

/// DateTimeUtc is an alias for `chrono`'s `DateTime<UTC>`. It implements `std::str::FromStr`'s
/// `from_str` method, and it makes `str`'s `parse` method to understand the accepted date formats
/// from this crate.
///
/// ```
/// use dateparser::DateTimeUtc;
///
/// // parsed is DateTimeUTC and parsed.0 is chrono's DateTime<Utc>
/// match "May 02, 2021 15:51:31 UTC".parse::<DateTimeUtc>() {
///     Ok(parsed) => println!("PARSED into UTC datetime {:?}", parsed.0),
///     Err(err) => println!("ERROR from parsing datetime string: {}", err)
/// }
/// ```
#[derive(Clone, Debug)]
pub struct DateTimeUtc(pub DateTime<Utc>);

impl std::str::FromStr for DateTimeUtc {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        parse(s).map(DateTimeUtc)
    }
}

/// This function tries to recognize the input datetime string with a list of accepted formats.
/// When timezone is not provided, this function assumes it's a [`chrono::Local`] datetime. For
/// custom timezone, use [`parse_with_timezone()`] instead.If all options are exhausted,
/// [`parse()`] will return an error to let the caller know that no formats were matched.
///
/// ```
/// use dateparser::parse;
/// use chrono::offset::{Local, Utc};
/// use chrono_tz::US::Pacific;
///
/// let parsed = parse("6:15pm").unwrap();
///
/// assert_eq!(
///     parsed,
///     Local::now().date().and_hms(18, 15, 0).with_timezone(&Utc),
/// );
///
/// assert_eq!(
///     parsed.with_timezone(&Pacific),
///     Local::now().date().and_hms(18, 15, 0).with_timezone(&Utc).with_timezone(&Pacific),
/// );
/// ```
pub fn parse(input: &str) -> Result<DateTime<Utc>> {
    Parse::new(&Local, None).parse(input)
}

/// Similar to [`parse()`], this function takes a datetime string and a custom [`chrono::TimeZone`],
/// and tries to parse the datetime string. When timezone is not given in the string, this function
/// will assume and parse the datetime by the custom timezone provided in this function's arguments.
///
/// ```
/// use dateparser::parse_with_timezone;
/// use chrono::offset::{Local, Utc};
/// use chrono_tz::US::Pacific;
///
/// let parsed_in_local = parse_with_timezone("6:15pm", &Local).unwrap();
/// assert_eq!(
///     parsed_in_local,
///     Local::now().date().and_hms(18, 15, 0).with_timezone(&Utc),
/// );
///
/// let parsed_in_utc = parse_with_timezone("6:15pm", &Utc).unwrap();
/// assert_eq!(
///     parsed_in_utc,
///     Utc::now().date().and_hms(18, 15, 0),
/// );
///
/// let parsed_in_pacific = parse_with_timezone("6:15pm", &Pacific).unwrap();
/// assert_eq!(
///     parsed_in_pacific,
///     Utc::now().with_timezone(&Pacific).date().and_hms(18, 15, 0).with_timezone(&Utc),
/// );
/// ```
pub fn parse_with_timezone<Tz2: TimeZone>(input: &str, tz: &Tz2) -> Result<DateTime<Utc>> {
    Parse::new(tz, None).parse(input)
}

/// Similar to [`parse()`] and [`parse_with_timezone()`], this function takes a datetime string, a
/// custom [`chrono::TimeZone`] and a default naive time. In addition to assuming timezone when
/// it's not given in datetime string, this function also use provided default naive time in parsed
/// [`chrono::DateTime`].
///
/// ```
/// use dateparser::parse_with;
/// use chrono::prelude::*;
///
/// let utc_now = Utc::now().time().trunc_subsecs(0);
/// let local_now = Local::now().time().trunc_subsecs(0);
/// let midnight_naive = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
/// let before_midnight_naive = NaiveTime::from_hms_opt(23, 59, 59).unwrap();
///
/// let parsed_with_local_now = parse_with("2021-10-09", &Local, local_now);
/// let parsed_with_local_midnight = parse_with("2021-10-09", &Local, midnight_naive);
/// let parsed_with_local_before_midnight = parse_with("2021-10-09", &Local, before_midnight_naive);
/// let parsed_with_utc_now = parse_with("2021-10-09", &Utc, utc_now);
/// let parsed_with_utc_midnight = parse_with("2021-10-09", &Utc, midnight_naive);
///
/// assert_eq!(
///     parsed_with_local_now.unwrap(),
///     Local.ymd(2021, 10, 9).and_time(local_now).unwrap().with_timezone(&Utc),
///     "parsed_with_local_now"
/// );
/// assert_eq!(
///     parsed_with_local_midnight.unwrap(),
///     Local.ymd(2021, 10, 9).and_time(midnight_naive).unwrap().with_timezone(&Utc),
///     "parsed_with_local_midnight"
/// );
/// assert_eq!(
///     parsed_with_local_before_midnight.unwrap(),
///     Local.ymd(2021, 10, 9).and_time(before_midnight_naive).unwrap().with_timezone(&Utc),
///     "parsed_with_local_before_midnight"
/// );
/// assert_eq!(
///     parsed_with_utc_now.unwrap(),
///     Utc.ymd(2021, 10, 9).and_time(utc_now).unwrap(),
///     "parsed_with_utc_now"
/// );
/// assert_eq!(
///     parsed_with_utc_midnight.unwrap(),
///     Utc.ymd(2021, 10, 9).and_hms(0, 0, 0),
///     "parsed_with_utc_midnight"
/// );
/// ```
pub fn parse_with<Tz2: TimeZone>(
    input: &str,
    tz: &Tz2,
    default_time: NaiveTime,
) -> Result<DateTime<Utc>> {
    Parse::new(tz, Some(default_time)).parse(input)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(Clone, Copy)]
    enum Trunc {
        Seconds,
        None,
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn parse_in_local() {
        let test_cases = vec![
            (
                "unix_timestamp",
                "1511648546",
                Utc.ymd(2017, 11, 25).and_hms(22, 22, 26),
                Trunc::None,
            ),
            (
                "rfc3339",
                "2017-11-25T22:34:50Z",
                Utc.ymd(2017, 11, 25).and_hms(22, 34, 50),
                Trunc::None,
            ),
            (
                "rfc2822",
                "Wed, 02 Jun 2021 06:31:39 GMT",
                Utc.ymd(2021, 6, 2).and_hms(6, 31, 39),
                Trunc::None,
            ),
            (
                "postgres_timestamp",
                "2019-11-29 08:08:05-08",
                Utc.ymd(2019, 11, 29).and_hms(16, 8, 5),
                Trunc::None,
            ),
            (
                "ymd_hms",
                "2021-04-30 21:14:10",
                Local
                    .ymd(2021, 4, 30)
                    .and_hms(21, 14, 10)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "ymd_hms_z",
                "2017-11-25 13:31:15 PST",
                Utc.ymd(2017, 11, 25).and_hms(21, 31, 15),
                Trunc::None,
            ),
            (
                "ymd",
                "2021-02-21",
                Local
                    .ymd(2021, 2, 21)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "ymd_z",
                "2021-02-21 PST",
                FixedOffset::west(8 * 3600)
                    .ymd(2021, 2, 21)
                    .and_time(
                        Utc::now()
                            .with_timezone(&FixedOffset::west(8 * 3600))
                            .time(),
                    )
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "hms",
                "4:00pm",
                Local::now()
                    .date()
                    .and_time(NaiveTime::from_hms(16, 0, 0))
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "hms_z",
                "6:00 AM PST",
                Utc::now()
                    .with_timezone(&FixedOffset::west(8 * 3600))
                    .date()
                    .and_time(NaiveTime::from_hms(6, 0, 0))
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "month_ymd",
                "2021-Feb-21",
                Local
                    .ymd(2021, 2, 21)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "month_md_hms",
                "May 27 02:45:27",
                Local
                    .ymd(Local::now().year(), 5, 27)
                    .and_hms(2, 45, 27)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "month_mdy_hms",
                "May 8, 2009 5:57:51 PM",
                Local
                    .ymd(2009, 5, 8)
                    .and_hms(17, 57, 51)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "month_mdy_hms_z",
                "May 02, 2021 15:51 UTC",
                Utc.ymd(2021, 5, 2).and_hms(15, 51, 0),
                Trunc::None,
            ),
            (
                "month_mdy",
                "May 25, 2021",
                Local
                    .ymd(2021, 5, 25)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "month_dmy_hms",
                "14 May 2019 19:11:40.164",
                Local
                    .ymd(2019, 5, 14)
                    .and_hms_milli(19, 11, 40, 164)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "month_dmy",
                "1 July 2013",
                Local
                    .ymd(2013, 7, 1)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "slash_mdy_hms",
                "03/19/2012 10:11:59",
                Local
                    .ymd(2012, 3, 19)
                    .and_hms(10, 11, 59)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "slash_mdy",
                "08/21/71",
                Local
                    .ymd(1971, 8, 21)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "slash_ymd_hms",
                "2012/03/19 10:11:59",
                Local
                    .ymd(2012, 3, 19)
                    .and_hms(10, 11, 59)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "slash_ymd",
                "2014/3/31",
                Local
                    .ymd(2014, 3, 31)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "dot_mdy_or_ymd",
                "2014.03.29",
                Local
                    .ymd(2014, 3, 29)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "mysql_log_timestamp",
                "171113 14:14:20",
                Local
                    .ymd(2017, 11, 13)
                    .and_hms(14, 14, 20)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "chinese_ymd_hms",
                "2014年04月08日11时25分18秒",
                Local
                    .ymd(2014, 4, 8)
                    .and_hms(11, 25, 18)
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "chinese_ymd",
                "2014年04月08日",
                Local
                    .ymd(2014, 4, 8)
                    .and_time(Local::now().time())
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
        ];

        for &(test, input, want, trunc) in test_cases.iter() {
            match trunc {
                Trunc::None => {
                    assert_eq!(
                        super::parse(input).unwrap(),
                        want,
                        "parse_in_local/{}/{}",
                        test,
                        input
                    )
                }
                Trunc::Seconds => assert_eq!(
                    super::parse(input)
                        .unwrap()
                        .trunc_subsecs(0)
                        .with_second(0)
                        .unwrap()
                        .with_minute(0)
                        .unwrap(),
                    want.trunc_subsecs(0)
                        .with_second(0)
                        .unwrap()
                        .with_minute(0)
                        .unwrap(),
                    "parse_in_local/{}/{}",
                    test,
                    input
                ),
            };
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn parse_with_timezone_in_utc() {
        let test_cases = vec![
            (
                "unix_timestamp",
                "1511648546",
                Utc.ymd(2017, 11, 25).and_hms(22, 22, 26),
                Trunc::None,
            ),
            (
                "rfc3339",
                "2017-11-25T22:34:50Z",
                Utc.ymd(2017, 11, 25).and_hms(22, 34, 50),
                Trunc::None,
            ),
            (
                "rfc2822",
                "Wed, 02 Jun 2021 06:31:39 GMT",
                Utc.ymd(2021, 6, 2).and_hms(6, 31, 39),
                Trunc::None,
            ),
            (
                "postgres_timestamp",
                "2019-11-29 08:08:05-08",
                Utc.ymd(2019, 11, 29).and_hms(16, 8, 5),
                Trunc::None,
            ),
            (
                "ymd_hms",
                "2021-04-30 21:14:10",
                Utc.ymd(2021, 4, 30).and_hms(21, 14, 10),
                Trunc::None,
            ),
            (
                "ymd_hms_z",
                "2017-11-25 13:31:15 PST",
                Utc.ymd(2017, 11, 25).and_hms(21, 31, 15),
                Trunc::None,
            ),
            (
                "ymd",
                "2021-02-21",
                Utc.ymd(2021, 2, 21).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "ymd_z",
                "2021-02-21 PST",
                FixedOffset::west(8 * 3600)
                    .ymd(2021, 2, 21)
                    .and_time(
                        Utc::now()
                            .with_timezone(&FixedOffset::west(8 * 3600))
                            .time(),
                    )
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::Seconds,
            ),
            (
                "hms",
                "4:00pm",
                Utc::now()
                    .date()
                    .and_time(NaiveTime::from_hms(16, 0, 0))
                    .unwrap(),
                Trunc::None,
            ),
            (
                "hms_z",
                "6:00 AM PST",
                FixedOffset::west(8 * 3600)
                    .from_local_date(
                        &Utc::now()
                            .with_timezone(&FixedOffset::west(8 * 3600))
                            .date()
                            .naive_local(),
                    )
                    .and_time(NaiveTime::from_hms(6, 0, 0))
                    .unwrap()
                    .with_timezone(&Utc),
                Trunc::None,
            ),
            (
                "month_ymd",
                "2021-Feb-21",
                Utc.ymd(2021, 2, 21).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "month_md_hms",
                "May 27 02:45:27",
                Utc.ymd(Utc::now().year(), 5, 27).and_hms(2, 45, 27),
                Trunc::None,
            ),
            (
                "month_mdy_hms",
                "May 8, 2009 5:57:51 PM",
                Utc.ymd(2009, 5, 8).and_hms(17, 57, 51),
                Trunc::None,
            ),
            (
                "month_mdy_hms_z",
                "May 02, 2021 15:51 UTC",
                Utc.ymd(2021, 5, 2).and_hms(15, 51, 0),
                Trunc::None,
            ),
            (
                "month_mdy",
                "May 25, 2021",
                Utc.ymd(2021, 5, 25).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "month_dmy_hms",
                "14 May 2019 19:11:40.164",
                Utc.ymd(2019, 5, 14).and_hms_milli(19, 11, 40, 164),
                Trunc::None,
            ),
            (
                "month_dmy",
                "1 July 2013",
                Utc.ymd(2013, 7, 1).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "slash_mdy_hms",
                "03/19/2012 10:11:59",
                Utc.ymd(2012, 3, 19).and_hms(10, 11, 59),
                Trunc::None,
            ),
            (
                "slash_mdy",
                "08/21/71",
                Utc.ymd(1971, 8, 21).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "slash_ymd_hms",
                "2012/03/19 10:11:59",
                Utc.ymd(2012, 3, 19).and_hms(10, 11, 59),
                Trunc::None,
            ),
            (
                "slash_ymd",
                "2014/3/31",
                Utc.ymd(2014, 3, 31).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "dot_mdy_or_ymd",
                "2014.03.29",
                Utc.ymd(2014, 3, 29).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
            (
                "mysql_log_timestamp",
                "171113 14:14:20",
                Utc.ymd(2017, 11, 13).and_hms(14, 14, 20),
                Trunc::None,
            ),
            (
                "chinese_ymd_hms",
                "2014年04月08日11时25分18秒",
                Utc.ymd(2014, 4, 8).and_hms(11, 25, 18),
                Trunc::None,
            ),
            (
                "chinese_ymd",
                "2014年04月08日",
                Utc.ymd(2014, 4, 8).and_time(Utc::now().time()).unwrap(),
                Trunc::Seconds,
            ),
        ];

        for &(test, input, want, trunc) in test_cases.iter() {
            match trunc {
                Trunc::None => {
                    assert_eq!(
                        super::parse_with_timezone(input, &Utc).unwrap(),
                        want,
                        "parse_with_timezone_in_utc/{}/{}",
                        test,
                        input
                    )
                }
                Trunc::Seconds => assert_eq!(
                    super::parse_with_timezone(input, &Utc)
                        .unwrap()
                        .trunc_subsecs(0)
                        .with_second(0)
                        .unwrap()
                        .with_minute(0)
                        .unwrap(),
                    want.trunc_subsecs(0)
                        .with_second(0)
                        .unwrap()
                        .with_minute(0)
                        .unwrap(),
                    "parse_with_timezone_in_utc/{}/{}",
                    test,
                    input
                ),
            };
        }
    }

    // test parse_with() with various timezones and times

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn parse_with_edt() {
        // Eastern Daylight Time (EDT) is from (as of 2023) 2nd Sun in Mar to 1st Sun in Nov
        // It is UTC -4

        let midnight_naive = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
        let before_midnight_naive = NaiveTime::from_hms_opt(23, 59, 59).unwrap();
        let us_edt = &FixedOffset::west_opt(4 * 3600).unwrap();

        let edt_test_cases = vec![
            ("ymd", "2023-04-21"),
            ("ymd_z", "2023-04-21 EDT"),
            ("month_ymd", "2023-Apr-21"),
            ("month_mdy", "April 21, 2023"),
            ("month_dmy", "21 April 2023"),
            ("slash_mdy", "04/21/23"),
            ("slash_ymd", "2023/4/21"),
            ("dot_mdy_or_ymd", "2023.04.21"),
            ("chinese_ymd", "2023年04月21日"),
        ];

        // test us_edt at midnight
        let us_edt_midnight_as_utc = Utc.ymd(2023, 4, 21).and_hms(4, 0, 0);

        for &(test, input) in edt_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, us_edt, midnight_naive).unwrap(),
                us_edt_midnight_as_utc,
                "parse_with/{test}/{input}",
            )
        }

        // test us_edt at 23:59:59 - UTC will be one day ahead
        let us_edt_before_midnight_as_utc = Utc.ymd(2023, 4, 22).and_hms(3, 59, 59);
        for &(test, input) in edt_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, us_edt, before_midnight_naive).unwrap(),
                us_edt_before_midnight_as_utc,
                "parse_with/{test}/{input}",
            )
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn parse_with_est() {
        // Eastern Standard Time (EST) is from (as of 2023) 1st Sun in Nov to 2nd Sun in Mar
        // It is UTC -5

        let midnight_naive = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
        let before_midnight_naive = NaiveTime::from_hms_opt(23, 59, 59).unwrap();
        let us_est = &FixedOffset::west(5 * 3600);

        let est_test_cases = vec![
            ("ymd", "2023-12-21"),
            ("ymd_z", "2023-12-21 EST"),
            ("month_ymd", "2023-Dec-21"),
            ("month_mdy", "December 21, 2023"),
            ("month_dmy", "21 December 2023"),
            ("slash_mdy", "12/21/23"),
            ("slash_ymd", "2023/12/21"),
            ("dot_mdy_or_ymd", "2023.12.21"),
            ("chinese_ymd", "2023年12月21日"),
        ];

        // test us_est at midnight
        let us_est_midnight_as_utc = Utc.ymd(2023, 12, 21).and_hms(5, 0, 0);

        for &(test, input) in est_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, us_est, midnight_naive).unwrap(),
                us_est_midnight_as_utc,
                "parse_with/{test}/{input}",
            )
        }

        // test us_est at 23:59:59 - UTC will be one day ahead
        let us_est_before_midnight_as_utc = Utc.ymd(2023, 12, 22).and_hms(4, 59, 59);
        for &(test, input) in est_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, us_est, before_midnight_naive).unwrap(),
                us_est_before_midnight_as_utc,
                "parse_with/{test}/{input}",
            )
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn parse_with_utc() {
        let midnight_naive = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
        let before_midnight_naive = NaiveTime::from_hms_opt(23, 59, 59).unwrap();
        let utc_test_cases = vec![
            ("ymd", "2023-12-21"),
            ("ymd_z", "2023-12-21 UTC"),
            ("month_ymd", "2023-Dec-21"),
            ("month_mdy", "December 21, 2023"),
            ("month_dmy", "21 December 2023"),
            ("slash_mdy", "12/21/23"),
            ("slash_ymd", "2023/12/21"),
            ("dot_mdy_or_ymd", "2023.12.21"),
            ("chinese_ymd", "2023年12月21日"),
        ];
        // test utc at midnight
        let utc_midnight = Utc.ymd(2023, 12, 21).and_hms(0, 0, 0);

        for &(test, input) in utc_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, &Utc, midnight_naive).unwrap(),
                utc_midnight,
                "parse_with/{test}/{input}",
            )
        }

        // test utc at 23:59:59
        let utc_before_midnight = Utc.ymd(2023, 12, 21).and_hms(23, 59, 59);
        for &(test, input) in utc_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, &Utc, before_midnight_naive).unwrap(),
                utc_before_midnight,
                "parse_with/{test}/{input}",
            )
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn parse_with_local() {
        let midnight_naive = NaiveTime::from_hms_opt(0, 0, 0).unwrap();
        let before_midnight_naive = NaiveTime::from_hms_opt(23, 59, 59).unwrap();
        let local_test_cases = [
            ("ymd", "2023-12-21"),
            ("month_ymd", "2023-Dec-21"),
            ("month_mdy", "December 21, 2023"),
            ("month_dmy", "21 December 2023"),
            ("slash_mdy", "12/21/23"),
            ("slash_ymd", "2023/12/21"),
            ("dot_mdy_or_ymd", "2023.12.21"),
            ("chinese_ymd", "2023年12月21日"),
        ];

        // test local at midnight
        let local_midnight_as_utc = Local.ymd(2023, 12, 21).and_hms(0, 0, 0).with_timezone(&Utc);

        for &(test, input) in local_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, &Local, midnight_naive).unwrap(),
                local_midnight_as_utc,
                "parse_with/{test}/{input}",
            )
        }

        // test local at 23:59:59
        let local_before_midnight_as_utc = Local
            .ymd(2023, 12, 21)
            .and_hms(23, 59, 59)
            .with_timezone(&Utc);

        for &(test, input) in local_test_cases.iter() {
            assert_eq!(
                super::parse_with(input, &Local, before_midnight_naive).unwrap(),
                local_before_midnight_as_utc,
                "parse_with/{test}/{input}",
            )
        }
    }
}