use std::num::NonZero;
use time::format_description::modifier::{Hour, WeekNumber, WeekNumberRepr};
use time::format_description::{BorrowedFormatItem, Component};
use time::parsing::Parsed;
use time::{Month, Time, Weekday, error};
#[test]
fn getters_setters() {
macro_rules! getters_setters {
($( $(#[$attr:meta])* $setter:ident $getter:ident $value:expr;)*) => {$(
$(#[$attr])*
{
let mut parsed = Parsed::new();
parsed.$setter($value);
assert_eq!(parsed.$getter(), Some($value));
}
)*};
}
getters_setters! {
set_year year 5;
set_year_last_two year_last_two 5;
set_iso_year iso_year 5;
set_iso_year_last_two iso_year_last_two 5;
set_month month Month::May;
set_sunday_week_number sunday_week_number 5;
set_monday_week_number monday_week_number 5;
set_iso_week_number iso_week_number NonZero::new(5).expect("valid value");
set_weekday weekday Weekday::Monday;
set_ordinal ordinal NonZero::new(5).expect("valid value");
set_day day NonZero::new(5).expect("valid value");
set_hour_24 hour_24 5;
set_hour_12 hour_12 NonZero::new(5).expect("valid value");
set_hour_12_is_pm hour_12_is_pm true;
set_minute minute 5;
set_second second 5;
set_subsecond subsecond 5;
set_offset_hour offset_hour 5;
#[expect(deprecated)] set_offset_minute offset_minute 5;
set_offset_minute_signed offset_minute_signed -5;
#[expect(deprecated)] set_offset_second offset_second 5;
set_offset_second_signed offset_second_signed -5;
}
#[expect(deprecated)]
{
let mut parsed = Parsed::new();
parsed.set_offset_minute(200);
assert_eq!(parsed.offset_minute(), None);
parsed.set_offset_second(200);
assert_eq!(parsed.offset_second(), None);
}
}
#[test]
fn builder_methods() {
#[expect(deprecated)]
let parsed = Parsed::new()
.with_year(5)
.and_then(|parsed| parsed.with_year_last_two(5))
.and_then(|parsed| parsed.with_iso_year(5))
.and_then(|parsed| parsed.with_iso_year_last_two(5))
.and_then(|parsed| parsed.with_month(Month::May))
.and_then(|parsed| parsed.with_sunday_week_number(5))
.and_then(|parsed| parsed.with_monday_week_number(5))
.and_then(|parsed| parsed.with_iso_week_number(NonZero::new(5).expect("valid value")))
.and_then(|parsed| parsed.with_weekday(Weekday::Monday))
.and_then(|parsed| parsed.with_ordinal(NonZero::new(5).expect("valid value")))
.and_then(|parsed| parsed.with_day(NonZero::new(5).expect("valid value")))
.and_then(|parsed| parsed.with_hour_24(5))
.and_then(|parsed| parsed.with_hour_12(NonZero::new(5).expect("valid value")))
.and_then(|parsed| parsed.with_hour_12_is_pm(true))
.and_then(|parsed| parsed.with_minute(5))
.and_then(|parsed| parsed.with_second(5))
.and_then(|parsed| parsed.with_subsecond(5))
.and_then(|parsed| parsed.with_offset_hour(5))
.and_then(|parsed| parsed.with_offset_minute(5))
.and_then(|parsed| parsed.with_offset_second(5))
.expect("all values are valid");
assert_eq!(parsed.year(), Some(5));
assert_eq!(parsed.year_last_two(), Some(5));
assert_eq!(parsed.iso_year(), Some(5));
assert_eq!(parsed.iso_year_last_two(), Some(5));
assert_eq!(parsed.month(), Some(Month::May));
assert_eq!(parsed.sunday_week_number(), Some(5));
assert_eq!(parsed.monday_week_number(), Some(5));
assert_eq!(
parsed.iso_week_number(),
Some(NonZero::new(5).expect("valid value"))
);
assert_eq!(parsed.weekday(), Some(Weekday::Monday));
assert_eq!(
parsed.ordinal(),
Some(NonZero::new(5).expect("valid value"))
);
assert_eq!(parsed.day(), Some(NonZero::new(5).expect("valid value")));
assert_eq!(parsed.hour_24(), Some(5));
assert_eq!(
parsed.hour_12(),
Some(NonZero::new(5).expect("valid value"))
);
assert_eq!(parsed.hour_12_is_pm(), Some(true));
assert_eq!(parsed.minute(), Some(5));
assert_eq!(parsed.second(), Some(5));
assert_eq!(parsed.subsecond(), Some(5));
assert_eq!(parsed.offset_hour(), Some(5));
#[expect(deprecated)]
{
assert_eq!(parsed.offset_minute(), Some(5));
assert_eq!(parsed.offset_second(), Some(5));
}
let parsed = Parsed::new()
.with_offset_minute_signed(-5)
.and_then(|parsed| parsed.with_offset_second_signed(-5))
.expect("all values are valid");
assert_eq!(parsed.offset_minute_signed(), Some(-5));
assert_eq!(parsed.offset_second_signed(), Some(-5));
#[expect(deprecated)]
{
assert!(Parsed::new().with_offset_minute(200).is_none());
assert!(Parsed::new().with_offset_second(200).is_none());
}
}
#[test]
fn single_item_parse() {
assert!(Time::parse("a", &BorrowedFormatItem::Literal(b"a")).is_err());
assert!(Time::parse("b", &BorrowedFormatItem::Literal(b"a")).is_err());
}
#[test]
fn component_err() {
macro_rules! input_or_empty {
() => {
b""
};
($input:expr) => {
$input
};
}
macro_rules! assert_invalid_component {
($component_name:expr, $component:expr $(, $input:expr)?) => {{
let mut parsed = Parsed::new();
assert_eq!(
parsed.parse_component(input_or_empty!($($input)?), $component),
Err(error::ParseFromDescription::InvalidComponent(
$component_name
))
);
}};
}
assert_invalid_component!("day", Component::Day(<_>::default()));
assert_invalid_component!("month", Component::Month(<_>::default()));
assert_invalid_component!("ordinal", Component::Ordinal(<_>::default()));
assert_invalid_component!("weekday", Component::Weekday(<_>::default()));
assert_invalid_component!("week number", Component::WeekNumber(<_>::default()));
assert_invalid_component!("year", Component::Year(<_>::default()));
assert_invalid_component!("minute", Component::Minute(<_>::default()));
assert_invalid_component!("period", Component::Period(<_>::default()));
assert_invalid_component!("second", Component::Second(<_>::default()));
assert_invalid_component!("subsecond", Component::Subsecond(<_>::default()));
assert_invalid_component!("offset hour", Component::OffsetHour(<_>::default()));
assert_invalid_component!("offset minute", Component::OffsetMinute(<_>::default()));
assert_invalid_component!("offset second", Component::OffsetSecond(<_>::default()));
assert_invalid_component!(
"week number",
Component::WeekNumber(WeekNumber::default().with_repr(WeekNumberRepr::Iso)),
b"00"
);
assert_invalid_component!(
"hour",
Component::Hour(Hour::default().with_is_12_hour_clock(true)),
b"00"
);
}