185 lines
7.0 KiB
Rust
185 lines
7.0 KiB
Rust
use std::fmt::Display;
|
|
use std::io;
|
|
use std::marker::PhantomData;
|
|
|
|
use rstest::rstest;
|
|
use time::error::{
|
|
ComponentRange, ConversionRange, DifferentVariant, Error, Format, IndeterminateOffset,
|
|
InvalidFormatDescription, InvalidVariant, Parse, ParseFromDescription, TryFromParsed,
|
|
};
|
|
use time::macros::format_description;
|
|
use time::parsing::Parsed;
|
|
use time::{Date, Time, format_description};
|
|
|
|
fn component_range() -> ComponentRange {
|
|
Date::from_ordinal_date(0, 367).expect_err("367 is not a valid day")
|
|
}
|
|
|
|
fn insufficient_type_information() -> Format {
|
|
Time::MIDNIGHT
|
|
.format(format_description!("[year]"))
|
|
.expect_err("missing date and UTC offset")
|
|
}
|
|
|
|
fn unexpected_trailing_characters() -> Parse {
|
|
Time::parse("a", format_description!("")).expect_err("should fail to parse")
|
|
}
|
|
|
|
fn invalid_format_description() -> InvalidFormatDescription {
|
|
format_description::parse_borrowed::<3>("[").expect_err("format description is invalid")
|
|
}
|
|
|
|
fn io_error() -> io::Error {
|
|
io::Error::last_os_error()
|
|
}
|
|
|
|
fn invalid_literal() -> ParseFromDescription {
|
|
Parsed::parse_literal(b"a", b"b").expect_err("should fail to parse")
|
|
}
|
|
|
|
#[rstest]
|
|
#[case(Parse::from(ParseFromDescription::InvalidComponent("a")))]
|
|
#[case(invalid_format_description())]
|
|
#[case(DifferentVariant)]
|
|
#[case(InvalidVariant)]
|
|
fn debug_reflexive<T>(#[case] value: T)
|
|
where
|
|
T: std::fmt::Debug,
|
|
{
|
|
assert_eq!(format!("{value:?}"), format!("{value:?}"))
|
|
}
|
|
|
|
#[rstest]
|
|
#[case(ConversionRange, Error::from(ConversionRange))]
|
|
#[case(component_range(), Error::from(component_range()))]
|
|
#[case(component_range(), TryFromParsed::from(component_range()))]
|
|
#[case(IndeterminateOffset, Error::from(IndeterminateOffset))]
|
|
#[case(
|
|
TryFromParsed::InsufficientInformation,
|
|
Error::from(TryFromParsed::InsufficientInformation)
|
|
)]
|
|
#[case(
|
|
insufficient_type_information(),
|
|
Error::from(insufficient_type_information())
|
|
)]
|
|
#[case(
|
|
Format::InvalidComponent("a"),
|
|
Error::from(Format::InvalidComponent("a"))
|
|
)]
|
|
#[case(
|
|
ParseFromDescription::InvalidComponent("a"),
|
|
Error::from(Parse::from(ParseFromDescription::InvalidComponent("a")))
|
|
)]
|
|
#[case(invalid_literal(), Parse::from(invalid_literal()))]
|
|
#[case(
|
|
component_range(),
|
|
Error::from(Parse::from(TryFromParsed::from(component_range())))
|
|
)]
|
|
#[case(
|
|
ParseFromDescription::InvalidComponent("a"),
|
|
Parse::from(ParseFromDescription::InvalidComponent("a"))
|
|
)]
|
|
#[case(component_range(), Parse::from(TryFromParsed::from(component_range())))]
|
|
#[case(
|
|
unexpected_trailing_characters(),
|
|
Error::from(unexpected_trailing_characters())
|
|
)]
|
|
#[case(
|
|
invalid_format_description(),
|
|
Error::from(invalid_format_description())
|
|
)]
|
|
#[case(io_error(), Format::from(io_error()))]
|
|
#[case(DifferentVariant, Error::from(DifferentVariant))]
|
|
#[case(InvalidVariant, Error::from(InvalidVariant))]
|
|
fn display_eq<T, U>(#[case] lhs: T, #[case] rhs: U)
|
|
where
|
|
T: Display,
|
|
U: Display,
|
|
{
|
|
assert_eq!(lhs.to_string(), rhs.to_string());
|
|
}
|
|
|
|
#[rstest]
|
|
#[case(Error::from(ConversionRange), PhantomData::<ConversionRange>)]
|
|
#[case(Error::from(component_range()), PhantomData::<ComponentRange>)]
|
|
#[case(TryFromParsed::from(component_range()), PhantomData::<ComponentRange>)]
|
|
#[case(Error::from(insufficient_type_information()), PhantomData::<Format>)]
|
|
#[case(Error::from(IndeterminateOffset), PhantomData::<IndeterminateOffset>)]
|
|
#[case(Parse::from(TryFromParsed::InsufficientInformation), PhantomData::<TryFromParsed>)]
|
|
#[case(Error::from(TryFromParsed::InsufficientInformation), PhantomData::<TryFromParsed>)]
|
|
#[case(Parse::from(ParseFromDescription::InvalidComponent("a")), PhantomData::<ParseFromDescription>)]
|
|
#[case(Error::from(ParseFromDescription::InvalidComponent("a")), PhantomData::<ParseFromDescription>)]
|
|
#[case(unexpected_trailing_characters(), PhantomData::<ParseFromDescription>)]
|
|
#[case(Error::from(unexpected_trailing_characters()), PhantomData::<ParseFromDescription>)]
|
|
#[case(Error::from(invalid_format_description()), PhantomData::<InvalidFormatDescription>)]
|
|
#[case(Format::from(io_error()), PhantomData::<io::Error>)]
|
|
#[case(Error::from(DifferentVariant), PhantomData::<DifferentVariant>)]
|
|
#[case(Error::from(InvalidVariant), PhantomData::<InvalidVariant>)]
|
|
fn source<E, S>(#[case] err: E, #[case] _source: PhantomData<S>)
|
|
where
|
|
E: std::error::Error + 'static,
|
|
S: std::error::Error + 'static,
|
|
{
|
|
assert!(
|
|
err.source()
|
|
.expect("error type should have source")
|
|
.is::<S>()
|
|
);
|
|
}
|
|
|
|
#[rstest]
|
|
#[case(TryFromParsed::InsufficientInformation)]
|
|
#[case(insufficient_type_information())]
|
|
#[case(Format::InvalidComponent("a"))]
|
|
fn source_none<T>(#[case] err: T)
|
|
where
|
|
T: std::error::Error,
|
|
{
|
|
assert!(err.source().is_none());
|
|
}
|
|
|
|
#[rstest]
|
|
fn component_name() {
|
|
assert_eq!(component_range().name(), "ordinal");
|
|
}
|
|
|
|
#[rstest]
|
|
#[case(ComponentRange::try_from(Error::from(component_range())))]
|
|
#[case(ConversionRange::try_from(Error::from(ConversionRange)))]
|
|
#[case(Format::try_from(Error::from(insufficient_type_information())))]
|
|
#[case(IndeterminateOffset::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(InvalidFormatDescription::try_from(Error::from(invalid_format_description())))]
|
|
#[case(ParseFromDescription::try_from(Error::from(invalid_literal())))]
|
|
#[case(ParseFromDescription::try_from(Parse::from(invalid_literal())))]
|
|
#[case(ParseFromDescription::try_from(unexpected_trailing_characters()))]
|
|
#[case(Parse::try_from(Error::from(unexpected_trailing_characters())))]
|
|
#[case(Parse::try_from(Error::from(invalid_literal())))]
|
|
#[case(Parse::try_from(Error::from(TryFromParsed::InsufficientInformation)))]
|
|
#[case(DifferentVariant::try_from(Error::from(DifferentVariant)))]
|
|
#[case(InvalidVariant::try_from(Error::from(InvalidVariant)))]
|
|
#[case(ComponentRange::try_from(TryFromParsed::ComponentRange(component_range())))]
|
|
#[case(TryFromParsed::try_from(Error::from(TryFromParsed::InsufficientInformation)))]
|
|
#[case(TryFromParsed::try_from(Parse::from(TryFromParsed::InsufficientInformation)))]
|
|
#[case(io::Error::try_from(Format::from(io_error())))]
|
|
fn conversion<T, E>(#[case] res: Result<T, E>) {
|
|
assert!(res.is_ok());
|
|
}
|
|
|
|
#[rstest]
|
|
#[case(ComponentRange::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(ConversionRange::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(Format::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(IndeterminateOffset::try_from(Error::from(ConversionRange)))]
|
|
#[case(InvalidFormatDescription::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(ParseFromDescription::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(Parse::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(DifferentVariant::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(InvalidVariant::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(ComponentRange::try_from(TryFromParsed::InsufficientInformation))]
|
|
#[case(TryFromParsed::try_from(Error::from(IndeterminateOffset)))]
|
|
#[case(TryFromParsed::try_from(unexpected_trailing_characters()))]
|
|
#[case(io::Error::try_from(insufficient_type_information()))]
|
|
fn conversion_err<T, E>(#[case] res: Result<T, E>) {
|
|
assert!(res.is_err());
|
|
}
|