1140 lines
25 KiB
Rust
1140 lines
25 KiB
Rust
// Prefer runtime checks if possible, as otherwise tests can't be run at all if something is
|
|
// changed.
|
|
|
|
use std::borrow::Borrow;
|
|
use std::error::Error as StdError;
|
|
use std::fmt::{Debug, Display};
|
|
use std::hash::Hash;
|
|
use std::iter::Sum;
|
|
use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
|
|
use std::panic::{RefUnwindSafe, UnwindSafe};
|
|
use std::time::{Duration as StdDuration, Instant as StdInstant, SystemTime};
|
|
|
|
use quickcheck::Arbitrary;
|
|
use rand08::distributions::{Distribution as DistributionRand08, Standard as StandardRand08};
|
|
use rand09::distr::{Distribution as DistributionRand09, StandardUniform as StandardUniformRand09};
|
|
use serde::{Deserialize, Serialize};
|
|
#[expect(deprecated)]
|
|
use time::Instant;
|
|
use time::format_description::well_known::iso8601;
|
|
use time::format_description::{BorrowedFormatItem, Component, modifier, well_known};
|
|
use time::formatting::Formattable;
|
|
use time::parsing::{Parsable, Parsed};
|
|
use time::{
|
|
Date, Duration, Error, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcDateTime, UtcOffset,
|
|
Weekday, error, ext,
|
|
};
|
|
|
|
#[expect(clippy::cognitive_complexity, reason = "all test the same thing")]
|
|
#[test]
|
|
fn alignment() {
|
|
macro_rules! assert_alignment {
|
|
($t:ty, $alignment:expr) => {
|
|
let alignment = $alignment;
|
|
assert_eq!(
|
|
align_of::<$t>(),
|
|
alignment,
|
|
"alignment of `{}` was {}",
|
|
stringify!($t),
|
|
alignment,
|
|
);
|
|
};
|
|
}
|
|
|
|
assert_alignment!(Date, 4);
|
|
assert_alignment!(Duration, 8);
|
|
assert_alignment!(OffsetDateTime, 4);
|
|
assert_alignment!(PrimitiveDateTime, 4);
|
|
assert_alignment!(UtcDateTime, 4);
|
|
assert_alignment!(Time, 4);
|
|
assert_alignment!(UtcOffset, 1);
|
|
assert_alignment!(error::ComponentRange, 8);
|
|
assert_alignment!(error::ConversionRange, 1);
|
|
assert_alignment!(error::DifferentVariant, 1);
|
|
assert_alignment!(error::IndeterminateOffset, 1);
|
|
assert_alignment!(modifier::Day, 1);
|
|
assert_alignment!(modifier::Hour, 1);
|
|
assert_alignment!(modifier::Minute, 1);
|
|
assert_alignment!(modifier::Month, 1);
|
|
assert_alignment!(modifier::OffsetHour, 1);
|
|
assert_alignment!(modifier::OffsetMinute, 1);
|
|
assert_alignment!(modifier::OffsetSecond, 1);
|
|
assert_alignment!(modifier::Ordinal, 1);
|
|
assert_alignment!(modifier::Period, 1);
|
|
assert_alignment!(modifier::Second, 1);
|
|
assert_alignment!(modifier::Subsecond, 1);
|
|
assert_alignment!(modifier::WeekNumber, 1);
|
|
assert_alignment!(modifier::Weekday, 1);
|
|
assert_alignment!(modifier::Year, 1);
|
|
assert_alignment!(well_known::Rfc2822, 1);
|
|
assert_alignment!(well_known::Rfc3339, 1);
|
|
assert_alignment!(
|
|
well_known::Iso8601<{ iso8601::Config::DEFAULT.encode() }>,
|
|
1
|
|
);
|
|
assert_alignment!(iso8601::Config, 1);
|
|
assert_alignment!(iso8601::DateKind, 1);
|
|
assert_alignment!(iso8601::FormattedComponents, 1);
|
|
assert_alignment!(iso8601::OffsetPrecision, 1);
|
|
assert_alignment!(iso8601::TimePrecision, 1);
|
|
assert_alignment!(Parsed, align_of::<u128>());
|
|
assert_alignment!(Month, 1);
|
|
assert_alignment!(Weekday, 1);
|
|
assert_alignment!(Error, 8);
|
|
assert_alignment!(error::Format, 8);
|
|
assert_alignment!(error::InvalidFormatDescription, 8);
|
|
assert_alignment!(error::Parse, 8);
|
|
assert_alignment!(error::ParseFromDescription, 8);
|
|
assert_alignment!(error::TryFromParsed, 8);
|
|
assert_alignment!(Component, 2);
|
|
assert_alignment!(BorrowedFormatItem<'_>, 8);
|
|
assert_alignment!(modifier::MonthRepr, 1);
|
|
assert_alignment!(modifier::Padding, 1);
|
|
assert_alignment!(modifier::SubsecondDigits, 1);
|
|
assert_alignment!(modifier::WeekNumberRepr, 1);
|
|
assert_alignment!(modifier::WeekdayRepr, 1);
|
|
assert_alignment!(modifier::YearRepr, 1);
|
|
}
|
|
|
|
#[expect(clippy::cognitive_complexity, reason = "all test the same thing")]
|
|
#[test]
|
|
fn size() {
|
|
macro_rules! assert_size {
|
|
($t:ty, $size:literal, $opt_size:literal) => {
|
|
assert!(
|
|
size_of::<$t>() <= $size,
|
|
concat!("size of `{}` used to be ", $size, ", but is now {}"),
|
|
stringify!($t),
|
|
size_of::<$t>(),
|
|
);
|
|
assert!(
|
|
size_of::<Option<$t>>() <= $opt_size,
|
|
concat!(
|
|
"size of `Option<{}>` used to be ",
|
|
$opt_size,
|
|
", but is now {}"
|
|
),
|
|
stringify!($t),
|
|
size_of::<Option<$t>>(),
|
|
);
|
|
};
|
|
}
|
|
|
|
assert_size!(Date, 4, 4);
|
|
assert_size!(Duration, 16, 16);
|
|
assert_size!(OffsetDateTime, 16, 16);
|
|
assert_size!(PrimitiveDateTime, 12, 12);
|
|
assert_size!(UtcDateTime, 12, 12);
|
|
assert_size!(Time, 8, 8);
|
|
assert_size!(UtcOffset, 3, 4);
|
|
assert_size!(error::ComponentRange, 24, 24);
|
|
assert_size!(error::ConversionRange, 0, 1);
|
|
assert_size!(error::DifferentVariant, 0, 1);
|
|
assert_size!(error::IndeterminateOffset, 0, 1);
|
|
assert_size!(modifier::Day, 1, 1);
|
|
assert_size!(modifier::Hour, 2, 2);
|
|
assert_size!(modifier::Minute, 1, 1);
|
|
assert_size!(modifier::Month, 3, 3);
|
|
assert_size!(modifier::OffsetHour, 2, 2);
|
|
assert_size!(modifier::OffsetMinute, 1, 1);
|
|
assert_size!(modifier::OffsetSecond, 1, 1);
|
|
assert_size!(modifier::Ordinal, 1, 1);
|
|
assert_size!(modifier::Period, 2, 2);
|
|
assert_size!(modifier::Second, 1, 1);
|
|
assert_size!(modifier::Subsecond, 1, 1);
|
|
assert_size!(modifier::WeekNumber, 2, 2);
|
|
assert_size!(modifier::Weekday, 3, 3);
|
|
assert_size!(modifier::Year, 5, 5);
|
|
assert_size!(well_known::Rfc2822, 0, 1);
|
|
assert_size!(well_known::Rfc3339, 0, 1);
|
|
assert_size!(
|
|
well_known::Iso8601<{ iso8601::Config::DEFAULT.encode() }>,
|
|
0,
|
|
1
|
|
);
|
|
assert_size!(iso8601::Config, 7, 7);
|
|
assert_size!(iso8601::DateKind, 1, 1);
|
|
assert_size!(iso8601::FormattedComponents, 1, 1);
|
|
assert_size!(iso8601::OffsetPrecision, 1, 1);
|
|
assert_size!(iso8601::TimePrecision, 2, 2);
|
|
assert_size!(Parsed, 64, 64);
|
|
assert_size!(Month, 1, 1);
|
|
assert_size!(Weekday, 1, 1);
|
|
assert_size!(Error, 48, 48);
|
|
assert_size!(error::Format, 24, 24);
|
|
assert_size!(error::InvalidFormatDescription, 48, 48);
|
|
assert_size!(error::Parse, 32, 32);
|
|
assert_size!(error::ParseFromDescription, 24, 24);
|
|
assert_size!(error::TryFromParsed, 24, 24);
|
|
assert_size!(Component, 6, 6);
|
|
assert_size!(BorrowedFormatItem<'_>, 24, 24);
|
|
assert_size!(modifier::MonthRepr, 1, 1);
|
|
assert_size!(modifier::Padding, 1, 1);
|
|
assert_size!(modifier::SubsecondDigits, 1, 1);
|
|
assert_size!(modifier::WeekNumberRepr, 1, 1);
|
|
assert_size!(modifier::WeekdayRepr, 1, 1);
|
|
assert_size!(modifier::YearRepr, 1, 1);
|
|
}
|
|
|
|
macro_rules! assert_obj_safe {
|
|
($($xs:path),+ $(,)?) => {
|
|
$(const _: Option<&dyn $xs> = None;)+
|
|
};
|
|
}
|
|
|
|
assert_obj_safe!(ext::NumericalDuration);
|
|
assert_obj_safe!(ext::NumericalStdDuration);
|
|
// `Parsable` is not object safe.
|
|
// `Formattable` is not object safe.
|
|
|
|
macro_rules! assert_impl {
|
|
($(#[$meta:meta])* $($(@$lifetimes:lifetime),+ ;)? $type:ty: $($trait:path),+ $(,)?) => {
|
|
$(#[$meta])*
|
|
const _: fn() = || {
|
|
fn assert_impl_all<$($($lifetimes,)+)? T: ?Sized $(+ $trait)+>() {}
|
|
assert_impl_all::<$type>();
|
|
};
|
|
};
|
|
}
|
|
|
|
assert_impl! { @'a; Date:
|
|
Add<Duration, Output = Date>,
|
|
Add<StdDuration, Output = Date>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
Ord,
|
|
PartialEq<Date>,
|
|
PartialOrd<Date>,
|
|
Serialize,
|
|
Sub<Date, Output = Duration>,
|
|
Sub<Duration, Output = Date>,
|
|
Sub<StdDuration, Output = Date>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
TryFrom<Parsed, Error = error::TryFromParsed>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; Duration:
|
|
Add<Duration, Output = Duration>,
|
|
Add<StdDuration, Output = Duration>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
Deserialize<'a>,
|
|
Div<Duration, Output = f64>,
|
|
Div<StdDuration, Output = f64>,
|
|
Div<f32, Output = Duration>,
|
|
Div<f64, Output = Duration>,
|
|
Div<i16, Output = Duration>,
|
|
Div<i32, Output = Duration>,
|
|
Div<i8, Output = Duration>,
|
|
Div<u16, Output = Duration>,
|
|
Div<u32, Output = Duration>,
|
|
Div<u8, Output = Duration>,
|
|
DivAssign<f32>,
|
|
DivAssign<f64>,
|
|
DivAssign<i16>,
|
|
DivAssign<i32>,
|
|
DivAssign<i8>,
|
|
DivAssign<u16>,
|
|
DivAssign<u32>,
|
|
DivAssign<u8>,
|
|
Hash,
|
|
Mul<f32, Output = Duration>,
|
|
Mul<f64, Output = Duration>,
|
|
Mul<i16, Output = Duration>,
|
|
Mul<i32, Output = Duration>,
|
|
Mul<i8, Output = Duration>,
|
|
Mul<u16, Output = Duration>,
|
|
Mul<u32, Output = Duration>,
|
|
Mul<u8, Output = Duration>,
|
|
MulAssign<f32>,
|
|
MulAssign<f64>,
|
|
MulAssign<i16>,
|
|
MulAssign<i32>,
|
|
MulAssign<i8>,
|
|
MulAssign<u16>,
|
|
MulAssign<u32>,
|
|
MulAssign<u8>,
|
|
Neg<Output = Duration>,
|
|
Ord,
|
|
PartialEq<Duration>,
|
|
PartialEq<StdDuration>,
|
|
PartialOrd<Duration>,
|
|
PartialOrd<StdDuration>,
|
|
Serialize,
|
|
Sub<Duration, Output = Duration>,
|
|
Sub<StdDuration, Output = Duration>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
Sum<&'a Duration>,
|
|
Sum<Duration>,
|
|
TryFrom<StdDuration, Error = error::ConversionRange>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { #[expect(deprecated)] Instant:
|
|
Add<Duration, Output = Instant>,
|
|
Add<StdDuration, Output = Instant>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
AsRef<StdInstant>,
|
|
Borrow<StdInstant>,
|
|
Clone,
|
|
Debug,
|
|
From<StdInstant>,
|
|
Hash,
|
|
Ord,
|
|
PartialEq<Instant>,
|
|
PartialEq<StdInstant>,
|
|
PartialOrd<Instant>,
|
|
PartialOrd<StdInstant>,
|
|
Sub<Duration, Output = Instant>,
|
|
Sub<StdDuration, Output = Instant>,
|
|
Sub<Instant, Output = Duration>,
|
|
Sub<StdInstant, Output = Duration>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; OffsetDateTime:
|
|
Add<Duration, Output = OffsetDateTime>,
|
|
Add<StdDuration, Output = OffsetDateTime>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
From<SystemTime>,
|
|
Hash,
|
|
Ord,
|
|
PartialEq<OffsetDateTime>,
|
|
PartialEq<SystemTime>,
|
|
PartialOrd<OffsetDateTime>,
|
|
PartialOrd<SystemTime>,
|
|
Serialize,
|
|
Sub<OffsetDateTime, Output = Duration>,
|
|
Sub<SystemTime, Output = Duration>,
|
|
Sub<Duration, Output = OffsetDateTime>,
|
|
Sub<StdDuration, Output = OffsetDateTime>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
TryFrom<Parsed, Error = error::TryFromParsed>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; PrimitiveDateTime:
|
|
Add<Duration, Output = PrimitiveDateTime>,
|
|
Add<StdDuration, Output = PrimitiveDateTime>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
Ord,
|
|
PartialEq<PrimitiveDateTime>,
|
|
PartialOrd<PrimitiveDateTime>,
|
|
Serialize,
|
|
Sub<Duration, Output = PrimitiveDateTime>,
|
|
Sub<StdDuration, Output = PrimitiveDateTime>,
|
|
Sub<PrimitiveDateTime>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
TryFrom<Parsed, Error = error::TryFromParsed>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; UtcDateTime:
|
|
Add<Duration, Output = UtcDateTime>,
|
|
Add<StdDuration, Output = UtcDateTime>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
Ord,
|
|
PartialEq<UtcDateTime>,
|
|
PartialEq<OffsetDateTime>,
|
|
PartialEq<SystemTime>,
|
|
PartialOrd<UtcDateTime>,
|
|
PartialOrd<OffsetDateTime>,
|
|
PartialOrd<SystemTime>,
|
|
Serialize,
|
|
Sub<Duration, Output = UtcDateTime>,
|
|
Sub<StdDuration, Output = UtcDateTime>,
|
|
Sub<UtcDateTime>,
|
|
Sub<OffsetDateTime>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
TryFrom<Parsed, Error = error::TryFromParsed>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; Time:
|
|
Add<Duration, Output = Time>,
|
|
Add<StdDuration, Output = Time>,
|
|
AddAssign<Duration>,
|
|
AddAssign<StdDuration>,
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
Ord,
|
|
PartialEq<Time>,
|
|
PartialOrd<Time>,
|
|
Serialize,
|
|
Sub<Duration, Output = Time>,
|
|
Sub<StdDuration, Output = Time>,
|
|
Sub<Time, Output = Duration>,
|
|
SubAssign<Duration>,
|
|
SubAssign<StdDuration>,
|
|
TryFrom<Parsed, Error = error::TryFromParsed>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; UtcOffset:
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
Neg,
|
|
Ord,
|
|
PartialEq<UtcOffset>,
|
|
PartialOrd<UtcOffset>,
|
|
Serialize,
|
|
TryFrom<Parsed, Error = error::TryFromParsed>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::ComponentRange:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
serde::de::Expected,
|
|
Hash,
|
|
PartialEq<error::ComponentRange>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
TryFrom<error::TryFromParsed, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::ConversionRange:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
PartialEq<error::ConversionRange>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::DifferentVariant:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
PartialEq<error::DifferentVariant>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::IndeterminateOffset:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
PartialEq<error::IndeterminateOffset>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Day:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Day>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Hour:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Hour>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Minute:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Minute>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Month:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Month>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::OffsetHour:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::OffsetHour>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::OffsetMinute:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::OffsetMinute>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::OffsetSecond:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::OffsetSecond>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Ordinal:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Ordinal>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Period:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Period>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Second:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Second>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Subsecond:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Subsecond>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::WeekNumber:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::WeekNumber>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Weekday:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Weekday>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Year:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Year>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { well_known::Rfc2822:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<well_known::Rfc2822>,
|
|
Copy,
|
|
Eq,
|
|
Formattable,
|
|
Parsable,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { well_known::Rfc3339:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<well_known::Rfc3339>,
|
|
Copy,
|
|
Eq,
|
|
Formattable,
|
|
Parsable,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { well_known::Iso8601::<{ iso8601::Config::DEFAULT.encode() }>:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<well_known::Iso8601<{ iso8601::Config::DEFAULT.encode() }>>,
|
|
Copy,
|
|
Eq,
|
|
Formattable,
|
|
Parsable,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { iso8601::Config:
|
|
Debug,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { iso8601::DateKind:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<iso8601::DateKind>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { iso8601::FormattedComponents:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<iso8601::FormattedComponents>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { iso8601::OffsetPrecision:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<iso8601::OffsetPrecision>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { iso8601::TimePrecision:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<iso8601::TimePrecision>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { Parsed:
|
|
Clone,
|
|
Debug,
|
|
Copy,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; Month:
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
PartialEq<Month>,
|
|
TryFrom<u8, Error = error::ComponentRange>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; Weekday:
|
|
Arbitrary,
|
|
Clone,
|
|
Debug,
|
|
Deserialize<'a>,
|
|
Display,
|
|
Hash,
|
|
PartialEq<Weekday>,
|
|
Serialize,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { Error:
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
From<error::ComponentRange>,
|
|
From<error::ConversionRange>,
|
|
From<error::DifferentVariant>,
|
|
From<error::Format>,
|
|
From<error::IndeterminateOffset>,
|
|
From<error::InvalidFormatDescription>,
|
|
From<error::Parse>,
|
|
From<error::ParseFromDescription>,
|
|
From<error::TryFromParsed>,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
}
|
|
assert_impl! { error::Format:
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
From<std::io::Error>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
}
|
|
assert_impl! { error::InvalidFormatDescription:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
PartialEq<error::InvalidFormatDescription>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::Parse:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
From<error::ParseFromDescription>,
|
|
From<error::TryFromParsed>,
|
|
PartialEq<error::Parse>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::ParseFromDescription:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
PartialEq<error::ParseFromDescription>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
TryFrom<error::Parse, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { error::TryFromParsed:
|
|
Clone,
|
|
Debug,
|
|
Display,
|
|
StdError,
|
|
From<error::ComponentRange>,
|
|
PartialEq<error::TryFromParsed>,
|
|
TryFrom<Error, Error = error::DifferentVariant>,
|
|
TryFrom<error::Parse, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; Component:
|
|
Clone,
|
|
Debug,
|
|
PartialEq<Component>,
|
|
PartialEq<BorrowedFormatItem<'a>>,
|
|
TryFrom<BorrowedFormatItem<'a>, Error = error::DifferentVariant>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; BorrowedFormatItem<'_>:
|
|
Clone,
|
|
Debug,
|
|
From<&'a [BorrowedFormatItem<'a>]>,
|
|
From<Component>,
|
|
PartialEq<&'a [BorrowedFormatItem<'a>]>,
|
|
PartialEq<Component>,
|
|
PartialEq<BorrowedFormatItem<'a>>,
|
|
Eq,
|
|
Formattable,
|
|
Parsable,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { @'a; &[BorrowedFormatItem<'_>]:
|
|
PartialEq<BorrowedFormatItem<'a>>,
|
|
TryFrom<BorrowedFormatItem<'a>, Error = error::DifferentVariant>,
|
|
}
|
|
assert_impl! { modifier::MonthRepr:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::MonthRepr>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::Padding:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::Padding>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::SubsecondDigits:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::SubsecondDigits>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::WeekNumberRepr:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::WeekNumberRepr>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::WeekdayRepr:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::WeekdayRepr>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { modifier::YearRepr:
|
|
Clone,
|
|
Debug,
|
|
Default,
|
|
PartialEq<modifier::YearRepr>,
|
|
Copy,
|
|
Eq,
|
|
RefUnwindSafe,
|
|
Send,
|
|
Sync,
|
|
Unpin,
|
|
UnwindSafe,
|
|
}
|
|
assert_impl! { StandardRand08:
|
|
DistributionRand08<Date>,
|
|
DistributionRand08<Duration>,
|
|
DistributionRand08<OffsetDateTime>,
|
|
DistributionRand08<UtcDateTime>,
|
|
DistributionRand08<PrimitiveDateTime>,
|
|
DistributionRand08<Time>,
|
|
DistributionRand08<UtcOffset>,
|
|
DistributionRand08<Month>,
|
|
DistributionRand08<Weekday>,
|
|
}
|
|
assert_impl! { StandardUniformRand09:
|
|
DistributionRand09<Date>,
|
|
DistributionRand09<Duration>,
|
|
DistributionRand09<OffsetDateTime>,
|
|
DistributionRand09<UtcDateTime>,
|
|
DistributionRand09<PrimitiveDateTime>,
|
|
DistributionRand09<Time>,
|
|
DistributionRand09<UtcOffset>,
|
|
DistributionRand09<Month>,
|
|
DistributionRand09<Weekday>,
|
|
}
|
|
assert_impl! { StdDuration:
|
|
Add<Duration, Output = Duration>,
|
|
AddAssign<Duration>,
|
|
Div<Duration, Output = f64>,
|
|
PartialEq<Duration>,
|
|
PartialOrd<Duration>,
|
|
Sub<Duration, Output = Duration>,
|
|
SubAssign<Duration>,
|
|
TryFrom<Duration>,
|
|
}
|
|
assert_impl! { #[expect(deprecated)] StdInstant:
|
|
Add<Duration, Output = StdInstant>,
|
|
AddAssign<Duration>,
|
|
Sub<Duration, Output = StdInstant>,
|
|
SubAssign<Duration>,
|
|
PartialEq<Instant>,
|
|
PartialOrd<Instant>,
|
|
From<Instant>,
|
|
Sub<Instant>,
|
|
}
|
|
assert_impl! { SystemTime:
|
|
Add<Duration, Output = SystemTime>,
|
|
AddAssign<Duration>,
|
|
Sub<Duration, Output = SystemTime>,
|
|
SubAssign<Duration>,
|
|
From<OffsetDateTime>,
|
|
PartialEq<OffsetDateTime>,
|
|
PartialOrd<OffsetDateTime>,
|
|
Sub<OffsetDateTime>,
|
|
}
|
|
assert_impl! { i8:
|
|
Mul<Duration>,
|
|
}
|
|
assert_impl! { i16:
|
|
Mul<Duration>,
|
|
}
|
|
assert_impl! { i32:
|
|
Mul<Duration>,
|
|
}
|
|
assert_impl! { u8:
|
|
Mul<Duration>,
|
|
From<Month>,
|
|
}
|
|
assert_impl! { u16:
|
|
Mul<Duration>,
|
|
}
|
|
assert_impl! { u32:
|
|
Mul<Duration>,
|
|
}
|
|
assert_impl! { f32:
|
|
Mul<Duration>,
|
|
}
|
|
assert_impl! { f64:
|
|
Mul<Duration>,
|
|
}
|