//! CSS properties for flexbox layout.

use alloc::string::{String, ToString};

use core::num::ParseFloatError;

use crate::corety::AzString;

use crate::{

    codegen::format::FormatAsRustCode,

    props::{

        basic::{

            error::ParseFloatErrorWithInput,

            length::{parse_float_value, FloatValue},

        },

        formatter::PrintAsCssValue,

    },

};

// --- flex-grow ---

/// Represents a `flex-grow` attribute, which dictates what proportion of the

/// remaining space in the flex container should be assigned to the item.

/// Default: 0

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct LayoutFlexGrow {

    pub inner: FloatValue,

}

impl core::fmt::Debug for LayoutFlexGrow {

}

impl Default for LayoutFlexGrow {

}

impl PrintAsCssValue for LayoutFlexGrow {

}

impl LayoutFlexGrow {

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum FlexGrowParseError<'a> {

    ParseFloat(ParseFloatError, &'a str),

    NegativeValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(FlexGrowParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { FlexGrowParseError<'a>, {

    ParseFloat(e, s) => format!("Invalid flex-grow value: \"{}\". Reason: {}", s, e),

    NegativeValue(s) => format!("Invalid flex-grow value: \"{}\". Flex-grow cannot be negative", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum FlexGrowParseErrorOwned {

    ParseFloat(ParseFloatErrorWithInput),

    NegativeValue(AzString),

}

#[cfg(feature = "parser")]

impl FlexGrowParseError<'_> {

            }

            }

        }

}

#[cfg(feature = "parser")]

impl FlexGrowParseErrorOwned {

            }

            }

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `flex-grow` value.

            } else {

            }

        }

    }

// --- flex-shrink ---

/// Represents a `flex-shrink` attribute, which dictates what proportion of

/// the negative space in the flex container should be removed from the item.

/// Default: 1

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct LayoutFlexShrink {

    pub inner: FloatValue,

}

impl core::fmt::Debug for LayoutFlexShrink {

}

impl Default for LayoutFlexShrink {

}

impl PrintAsCssValue for LayoutFlexShrink {

}

impl LayoutFlexShrink {

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum FlexShrinkParseError<'a> {

    ParseFloat(ParseFloatError, &'a str),

    NegativeValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(FlexShrinkParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { FlexShrinkParseError<'a>, {

    ParseFloat(e, s) => format!("Invalid flex-shrink value: \"{}\". Reason: {}", s, e),

    NegativeValue(s) => format!("Invalid flex-shrink value: \"{}\". Flex-shrink cannot be negative", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum FlexShrinkParseErrorOwned {

    ParseFloat(ParseFloatErrorWithInput),

    NegativeValue(AzString),

}

#[cfg(feature = "parser")]

impl FlexShrinkParseError<'_> {

            }

            }

        }

}

#[cfg(feature = "parser")]

impl FlexShrinkParseErrorOwned {

            }

            }

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `flex-shrink` value.

            } else {

            }

        }

    }

// --- flex-direction ---

/// Represents a `flex-direction` attribute, which establishes the main-axis,

/// thus defining the direction flex items are placed in the flex container.

/// Default: `Row`

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum LayoutFlexDirection {

    #[default]

    Row,

    RowReverse,

    Column,

    ColumnReverse,

}

/// Represents the main or cross axis of a flex container.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub enum LayoutAxis {

    Horizontal,

    Vertical,

}

impl LayoutFlexDirection {

        }

}

impl PrintAsCssValue for LayoutFlexDirection {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum FlexDirectionParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(FlexDirectionParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { FlexDirectionParseError<'a>, {

    InvalidValue(s) => format!("Invalid flex-direction value: \"{}\"", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum FlexDirectionParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl FlexDirectionParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl FlexDirectionParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `flex-direction` value.

    }

// --- flex-wrap ---

/// Represents a `flex-wrap` attribute, which determines whether flex items

/// are forced onto one line or can wrap onto multiple lines.

/// Default: `NoWrap`

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum LayoutFlexWrap {

    Wrap,

    #[default]

    NoWrap,

    WrapReverse,

}

impl PrintAsCssValue for LayoutFlexWrap {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum FlexWrapParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(FlexWrapParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { FlexWrapParseError<'a>, {

    InvalidValue(s) => format!("Invalid flex-wrap value: \"{}\"", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum FlexWrapParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl FlexWrapParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl FlexWrapParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `flex-wrap` value.

    }

// --- justify-content ---

/// Represents a `justify-content` attribute, which defines the alignment

/// along the main axis.

/// Default: `Start` (flex-start)

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum LayoutJustifyContent {

    FlexStart,

    FlexEnd,

    #[default]

    Start,

    End,

    Center,

    SpaceBetween,

    SpaceAround,

    SpaceEvenly,

}

impl PrintAsCssValue for LayoutJustifyContent {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum JustifyContentParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(JustifyContentParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { JustifyContentParseError<'a>, {

    InvalidValue(s) => format!("Invalid justify-content value: \"{}\"", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum JustifyContentParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl JustifyContentParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl JustifyContentParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `justify-content` value.

    }

// --- align-items ---

/// Represents an `align-items` attribute, which defines the default behavior for

/// how flex items are laid out along the cross axis on the current line.

/// Default: `Stretch`

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum LayoutAlignItems {

    #[default]

    Stretch,

    Center,

    Start,

    End,

    Baseline,

}

impl PrintAsCssValue for LayoutAlignItems {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum AlignItemsParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(AlignItemsParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { AlignItemsParseError<'a>, {

    InvalidValue(s) => format!("Invalid align-items value: \"{}\"", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum AlignItemsParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl AlignItemsParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl AlignItemsParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `align-items` value.

    }

// --- align-content ---

/// Represents an `align-content` attribute, which aligns a flex container's lines

/// within it when there is extra space in the cross-axis.

/// Default: `Stretch`

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum LayoutAlignContent {

    #[default]

    Stretch,

    Center,

    Start,

    End,

    SpaceBetween,

    SpaceAround,

}

impl PrintAsCssValue for LayoutAlignContent {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum AlignContentParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(AlignContentParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { AlignContentParseError<'a>, {

    InvalidValue(s) => format!("Invalid align-content value: \"{}\"", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum AlignContentParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl AlignContentParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl AlignContentParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `align-content` value.

    }

// --- align-self ---

/// Represents an `align-self` attribute, which allows the default alignment

/// (or the one specified by align-items) to be overridden for individual flex items.

/// Default: `Auto`

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum LayoutAlignSelf {

    #[default]

    Auto,

    Stretch,

    Center,

    Start,

    End,

    Baseline,

}

impl PrintAsCssValue for LayoutAlignSelf {

        })

}

impl FormatAsRustCode for LayoutAlignSelf {

            }

        )

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum AlignSelfParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(AlignSelfParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { AlignSelfParseError<'a>, {

    InvalidValue(s) => format!("Invalid align-self value: \"{}\"", s),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum AlignSelfParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl AlignSelfParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl AlignSelfParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `align-self` value.

    }

// --- flex-basis ---

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// Represents a `flex-basis` attribute

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

#[derive(Default)]

pub enum LayoutFlexBasis {

    /// auto

    #[default]

    Auto,

    /// Fixed size

    Exact(crate::props::basic::pixel::PixelValue),

}

impl core::fmt::Debug for LayoutFlexBasis {

}

impl PrintAsCssValue for LayoutFlexBasis {

        }

}

impl FormatAsRustCode for LayoutFlexBasis {

                )

            }

        }

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum FlexBasisParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(FlexBasisParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { FlexBasisParseError<'a>, {

    InvalidValue(e) => format!("Invalid flex-basis value: \"{}\"", e),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum FlexBasisParseErrorOwned {

    InvalidValue(AzString),

}

#[cfg(feature = "parser")]

impl FlexBasisParseError<'_> {

            }

        }

}

#[cfg(feature = "parser")]

impl FlexBasisParseErrorOwned {

            }

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `flex-basis` value.

    use crate::props::basic::pixel::parse_pixel_value;

    }

#[cfg(all(test, feature = "parser"))]

mod tests {

    // Tests assert that parsed values equal the exact source literals.

    #![allow(clippy::float_cmp)]

    use super::*;

    use crate::props::basic::pixel::PixelValue;

    #[test]

    #[test]

    #[test]

            LayoutFlexDirection::Row

        );

            LayoutFlexDirection::RowReverse

        );

            LayoutFlexDirection::Column

        );

            LayoutFlexDirection::ColumnReverse

        );

            LayoutFlexDirection::Row

        );

    #[test]

            LayoutFlexWrap::NoWrap

        );

            LayoutFlexWrap::Wrap

        );

            LayoutFlexWrap::WrapReverse

        );

            LayoutFlexWrap::Wrap

        );

    #[test]

            LayoutJustifyContent::FlexStart

        );

            LayoutJustifyContent::FlexEnd

        );

            LayoutJustifyContent::Start

        );

            LayoutJustifyContent::End

        );

            LayoutJustifyContent::Center

        );

            LayoutJustifyContent::SpaceBetween

        );

            LayoutJustifyContent::SpaceAround

        );

            LayoutJustifyContent::SpaceEvenly

        );

            LayoutJustifyContent::Center

        );

    #[test]

            LayoutAlignItems::Stretch

        );

            LayoutAlignItems::Start

        );

            LayoutAlignItems::End

        );

            LayoutAlignItems::Start

        );

            LayoutAlignItems::End

        );

            LayoutAlignItems::Center

        );

            LayoutAlignItems::Baseline

        );

    #[test]

            LayoutAlignContent::Stretch

        );

            LayoutAlignContent::Start

        );

            LayoutAlignContent::End

        );

            LayoutAlignContent::Center

        );

            LayoutAlignContent::SpaceBetween

        );

            LayoutAlignContent::SpaceAround

        );

    #[test]

            LayoutFlexBasis::Auto

        );

        );

        );

        );

        // Liberal parsing accepts unitless numbers (treated as px)

        );

        );

}

#[cfg(test)]

#[allow(clippy::float_cmp)] // fixed-point (1/1000) values are exactly representable in f32

mod autotest_generated {

    use super::*;

    use crate::props::basic::{length::FloatValue, pixel::PixelValue};

    // ---------------------------------------------------------------------

    // LayoutFlexGrow::new / const_new  (constructor + numeric)

    // ---------------------------------------------------------------------

    /// `new()` goes through f32 (`isize -> f32 -> *1000 -> isize`) while

    /// `const_new()` uses pure integer math (`value * 1000`). For magnitudes

    /// where both encodings are exact they must agree bit-for-bit.

    #[test]

    fn flex_grow_new_agrees_with_const_new_for_exact_ints() {

        for v in [-10_000_isize, -1000, -7, -1, 0, 1, 7, 1000, 10_000] {

            assert_eq!(

                LayoutFlexGrow::new(v).inner.number(),

                LayoutFlexGrow::const_new(v).inner.number(),

                "new()/const_new() disagree for {v}"

            );

            assert_eq!(LayoutFlexGrow::new(v).inner.get(), v as f32);

        }

    }

    /// `new()` runs the value through `f32 as isize`, which saturates rather

    /// than wrapping or panicking: MIN/MAX must survive without UB or overflow.

    #[test]

    fn flex_grow_new_saturates_at_isize_extremes() {

        let max = LayoutFlexGrow::new(isize::MAX);

        let min = LayoutFlexGrow::new(isize::MIN);

        assert_eq!(max.inner.number(), isize::MAX, "MAX must saturate, not wrap");

        assert_eq!(min.inner.number(), isize::MIN, "MIN must saturate, not wrap");

        assert!(max.inner.get().is_finite());

        assert!(min.inner.get().is_finite());

        assert!(max.inner.get() > 0.0);

        assert!(min.inner.get() < 0.0);

    }

    /// `const_new()` stores `value * 1000` in an `isize`, so the largest safe

    /// input is `isize::MAX / 1000`. Anything above that overflows the

    /// multiplication (debug-panic / release-wrap) — this pins the documented

    /// safe boundary. See the report note on `const_new` overflow.

    #[test]

    fn flex_grow_const_new_at_safe_encoding_boundary() {

        let hi = isize::MAX / 1000;

        let lo = isize::MIN / 1000;

        assert_eq!(LayoutFlexGrow::const_new(hi).inner.number(), hi * 1000);

        assert_eq!(LayoutFlexGrow::const_new(lo).inner.number(), lo * 1000);

        assert!(LayoutFlexGrow::const_new(hi).inner.get().is_finite());

        assert!(LayoutFlexGrow::const_new(lo).inner.get().is_finite());

    }

    /// Zero / negative inputs are stored verbatim: the constructors perform no

    /// CSS validation (`flex-grow` may not be negative), only the parser does.

    #[test]

    fn flex_grow_const_new_zero_and_negative_are_not_clamped() {

        const ZERO: LayoutFlexGrow = LayoutFlexGrow::const_new(0);

        const NEG: LayoutFlexGrow = LayoutFlexGrow::const_new(-3);

        assert_eq!(ZERO.inner.get(), 0.0);

        assert_eq!(ZERO.inner.number(), 0);

        assert_eq!(NEG.inner.get(), -3.0);

        assert_eq!(LayoutFlexGrow::new(-3).inner.get(), -3.0);

    }

    #[test]

    fn flex_grow_and_shrink_defaults_match_css_initial_values() {

        assert_eq!(LayoutFlexGrow::default().inner.get(), 0.0);

        assert_eq!(LayoutFlexShrink::default().inner.get(), 1.0);

        // Ord is derived over the fixed-point isize, so it must track the float.

        assert!(LayoutFlexGrow::const_new(1) < LayoutFlexGrow::const_new(2));

        assert!(LayoutFlexGrow::const_new(-1) < LayoutFlexGrow::const_new(0));

    }

    // ---------------------------------------------------------------------

    // interpolate()  (numeric: zero / limits / NaN / inf / overflow)

    // ---------------------------------------------------------------------

    fn grow(v: f32) -> LayoutFlexGrow {

        LayoutFlexGrow {

            inner: FloatValue::new(v),

        }

    }

    fn shrink(v: f32) -> LayoutFlexShrink {

        LayoutFlexShrink {

            inner: FloatValue::new(v),

        }

    }

    #[test]

    fn flex_grow_interpolate_endpoints_midpoint_and_extrapolation() {

        let a = grow(0.0);

        let b = grow(10.0);

        assert_eq!(a.interpolate(&b, 0.0).inner.get(), 0.0);

        assert_eq!(a.interpolate(&b, 1.0).inner.get(), 10.0);

        assert_eq!(a.interpolate(&b, 0.5).inner.get(), 5.0);

        // t is not clamped: extrapolation past the endpoints is well-defined.

        assert_eq!(a.interpolate(&b, 2.0).inner.get(), 20.0);

        assert_eq!(a.interpolate(&b, -1.0).inner.get(), -10.0);

    }

    /// A NaN `t` produces NaN internally; the `f32 as isize` cast maps NaN to 0,

    /// so the result is a defined 0.0 rather than a NaN or a panic.

    #[test]

    fn flex_grow_interpolate_nan_t_collapses_to_zero() {

        let a = grow(2.0);

        let b = grow(8.0);

        let out = a.interpolate(&b, f32::NAN);

        assert!(out.inner.get().is_finite(), "NaN must not leak into the value");

        assert_eq!(out.inner.get(), 0.0);

        assert_eq!(out.inner.number(), 0);

    }

    /// Infinite `t` overflows the lerp; the saturating cast must keep the result

    /// finite and correctly signed instead of panicking.

    #[test]

    fn flex_grow_interpolate_infinite_t_saturates_finite() {

        let a = grow(0.0);

        let b = grow(10.0);

        let pos = a.interpolate(&b, f32::INFINITY);

        assert!(pos.inner.get().is_finite());

        assert!(pos.inner.get() > 0.0);

        assert_eq!(pos.inner.number(), isize::MAX);

        let neg = a.interpolate(&b, f32::NEG_INFINITY);

        assert!(neg.inner.get().is_finite());

        assert!(neg.inner.get() < 0.0);

        assert_eq!(neg.inner.number(), isize::MIN);

        // Degenerate case: equal endpoints => (b - a) * inf == NaN => 0.0.

        let same = grow(4.0).interpolate(&grow(4.0), f32::INFINITY);

        assert!(same.inner.get().is_finite());

        assert_eq!(same.inner.get(), 0.0);

    }

    /// Interpolating between the saturated extremes must never panic and must

    /// always yield a finite, decodable value.

    #[test]

    fn flex_grow_interpolate_extreme_endpoints_stay_finite() {

        let a = LayoutFlexGrow::new(isize::MAX);

        let b = LayoutFlexGrow::new(isize::MIN);

        for t in [

            0.0_f32,

            0.5,

            1.0,

            -1.0,

            1e30,

            -1e30,

            f32::MIN_POSITIVE,

            f32::NAN,

            f32::INFINITY,

            f32::NEG_INFINITY,

        ] {

            let out = a.interpolate(&b, t);

            assert!(

                out.inner.get().is_finite(),

                "interpolate(MAX, MIN, {t}) produced a non-finite value"

            );

        }

        // t = 0 must return `self` even at the saturation boundary.

        assert_eq!(a.interpolate(&b, 0.0).inner.get(), a.inner.get());

    }

    #[test]

    fn flex_shrink_interpolate_endpoints_nan_and_inf() {

        let a = shrink(1.0);

        let b = shrink(3.0);

        assert_eq!(a.interpolate(&b, 0.0).inner.get(), 1.0);

        assert_eq!(a.interpolate(&b, 1.0).inner.get(), 3.0);

        assert_eq!(a.interpolate(&b, 0.5).inner.get(), 2.0);

        assert_eq!(a.interpolate(&b, -2.0).inner.get(), -3.0);

        assert_eq!(a.interpolate(&b, f32::NAN).inner.get(), 0.0);

        assert!(a.interpolate(&b, f32::INFINITY).inner.get().is_finite());

        assert!(a.interpolate(&b, f32::NEG_INFINITY).inner.get().is_finite());

        let extreme = LayoutFlexShrink {

            inner: FloatValue::new(f32::MAX),

        };

        assert!(extreme.interpolate(&a, 0.5).inner.get().is_finite());

        assert!(extreme.interpolate(&a, f32::NAN).inner.get().is_finite());

    }

    // ---------------------------------------------------------------------

    // LayoutFlexDirection::get_axis / is_reverse  (getter + predicate)

    // ---------------------------------------------------------------------

    const ALL_DIRECTIONS: [LayoutFlexDirection; 4] = [

        LayoutFlexDirection::Row,

        LayoutFlexDirection::RowReverse,

        LayoutFlexDirection::Column,

        LayoutFlexDirection::ColumnReverse,

    ];

    #[test]

    fn flex_direction_get_axis_is_exhaustive_and_reverse_invariant() {

        assert_eq!(LayoutFlexDirection::Row.get_axis(), LayoutAxis::Horizontal);

        assert_eq!(

            LayoutFlexDirection::RowReverse.get_axis(),

            LayoutAxis::Horizontal

        );

        assert_eq!(LayoutFlexDirection::Column.get_axis(), LayoutAxis::Vertical);

        assert_eq!(

            LayoutFlexDirection::ColumnReverse.get_axis(),

            LayoutAxis::Vertical

        );

        // Invariant: reversing a direction never changes its axis.

        assert_eq!(

            LayoutFlexDirection::Row.get_axis(),

            LayoutFlexDirection::RowReverse.get_axis()

        );

        assert_eq!(