Quelle  meta.rs

// 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>,
}