//! CSS properties for border style, width, and color.

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

use core::fmt;

use crate::corety::AzString;

#[cfg(feature = "parser")]

use crate::props::basic::{color::parse_css_color, pixel::parse_pixel_value};

use crate::{

    css::PrintAsCssValue,

    props::{

        basic::{

            color::{ColorU, CssColorParseError, CssColorParseErrorOwned},

            pixel::{

                CssPixelValueParseError, CssPixelValueParseErrorOwned, PixelValue,

                MEDIUM_BORDER_THICKNESS, THICK_BORDER_THICKNESS, THIN_BORDER_THICKNESS,

            },

        },

        macros::PixelValueTaker,

    },

};

/// Style of a `border`: solid, double, dash, ridge, etc.

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

#[repr(C)]

// +spec:box-model:28fad6 - Border style variants including groove/ridge/inset/outset for separated/collapsing border models

#[derive(Default)]

pub enum BorderStyle {

    #[default]

    None,

    Solid,

    Double,

    Dotted,

    Dashed,

    Hidden,

    Groove,

    Ridge,

    Inset,

    Outset,

}

impl fmt::Display for BorderStyle {

            }

        )

}

impl PrintAsCssValue for BorderStyle {

}

/// Internal macro to reduce boilerplate for defining border-top, -right, -bottom, -left properties.

macro_rules! define_border_side_property {

    // For types that have a simple inner value and can be formatted with Display

    ($struct_name:ident, $inner_type:ty, $default:expr) => {

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

        #[repr(C)]

        pub struct $struct_name {

            pub inner: $inner_type,

        }

        impl ::core::fmt::Debug for $struct_name {

        }

        impl Default for $struct_name {

        }

    };

    // Specialization for ColorU

    ($struct_name:ident,ColorU) => {

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

        #[repr(C)]

        pub struct $struct_name {

            pub inner: ColorU,

        }

        impl ::core::fmt::Debug for $struct_name {

        }

        // The default border color is 'currentcolor', but for simplicity we default to BLACK.

        // The style property resolver should handle the 'currentcolor' logic.

        impl Default for $struct_name {

        }

        impl $struct_name {

        }

    };

    // NOTE: no separate `PixelValue` specialization arm — the generic

    // `($struct_name, $inner_type:ty, $default)` arm above already matches

    // `define_border_side_property!(.., PixelValue, ..)` (PixelValue is a `:ty`),

    // so a 3-arg PixelValue arm here would be unreachable (unused_macro_rules).

}

// --- Individual Property Structs ---

// +spec:box-model:8c49fe - Border style properties (none, solid, double, dashed, etc.) and border color defaulting to element's color

// Border Style (border-*-style)

/// CSS `border-top-style` property (e.g. `solid`, `dashed`, `none`).

define_border_side_property!(StyleBorderTopStyle, BorderStyle, BorderStyle::None);

/// CSS `border-right-style` property (e.g. `solid`, `dashed`, `none`).

define_border_side_property!(StyleBorderRightStyle, BorderStyle, BorderStyle::None);

/// CSS `border-bottom-style` property (e.g. `solid`, `dashed`, `none`).

define_border_side_property!(StyleBorderBottomStyle, BorderStyle, BorderStyle::None);

/// CSS `border-left-style` property (e.g. `solid`, `dashed`, `none`).

define_border_side_property!(StyleBorderLeftStyle, BorderStyle, BorderStyle::None);

// Formatting implementations for border side style values

impl crate::codegen::format::FormatAsRustCode for StyleBorderTopStyle {

        )

}

impl crate::codegen::format::FormatAsRustCode for StyleBorderRightStyle {

        )

}

impl crate::codegen::format::FormatAsRustCode for StyleBorderLeftStyle {

        )

}

impl crate::codegen::format::FormatAsRustCode for StyleBorderBottomStyle {

        )

}

// Border Color (border-*-color)

/// CSS `border-top-color` property. Defaults to `ColorU::BLACK`.

define_border_side_property!(StyleBorderTopColor, ColorU);

/// CSS `border-right-color` property. Defaults to `ColorU::BLACK`.

define_border_side_property!(StyleBorderRightColor, ColorU);

/// CSS `border-bottom-color` property. Defaults to `ColorU::BLACK`.

define_border_side_property!(StyleBorderBottomColor, ColorU);

/// CSS `border-left-color` property. Defaults to `ColorU::BLACK`.

define_border_side_property!(StyleBorderLeftColor, ColorU);

// Border Width (border-*-width)

// The default width is 'medium', which corresponds to 3px.

// Import from pixel.rs for consistency.

/// CSS `border-top-width` property. Defaults to `MEDIUM_BORDER_THICKNESS` (3px).

define_border_side_property!(LayoutBorderTopWidth, PixelValue, MEDIUM_BORDER_THICKNESS);

/// CSS `border-right-width` property. Defaults to `MEDIUM_BORDER_THICKNESS` (3px).

define_border_side_property!(LayoutBorderRightWidth, PixelValue, MEDIUM_BORDER_THICKNESS);

/// CSS `border-bottom-width` property. Defaults to `MEDIUM_BORDER_THICKNESS` (3px).

define_border_side_property!(LayoutBorderBottomWidth, PixelValue, MEDIUM_BORDER_THICKNESS);

/// CSS `border-left-width` property. Defaults to `MEDIUM_BORDER_THICKNESS` (3px).

define_border_side_property!(LayoutBorderLeftWidth, PixelValue, MEDIUM_BORDER_THICKNESS);

macro_rules! impl_border_width_helpers {

    ($($t:ty),+) => { $(

        impl $t {

        }

    )+ };

}

impl_border_width_helpers!(

    LayoutBorderTopWidth,

    LayoutBorderRightWidth,

    LayoutBorderBottomWidth,

    LayoutBorderLeftWidth

);

/// Represents the three components of a border shorthand property, used as an intermediate

/// representation during parsing.

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

pub struct StyleBorderSide {

    pub border_width: PixelValue,

    pub border_style: BorderStyle,

    pub border_color: ColorU,

}

// --- PARSERS ---

// -- BorderStyle Parser --

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum CssBorderStyleParseError<'a> {

    InvalidStyle(&'a str),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(CssBorderStyleParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { CssBorderStyleParseError<'a>, {

    InvalidStyle(val) => format!("Invalid border style: \"{}\"", val),

}}

#[cfg(feature = "parser")]

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

#[repr(C, u8)]

pub enum CssBorderStyleParseErrorOwned {

    InvalidStyle(AzString),

}

#[cfg(feature = "parser")]

impl CssBorderStyleParseError<'_> {

            }

        }

}

#[cfg(feature = "parser")]

impl CssBorderStyleParseErrorOwned {

            }

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-style` value.

    }

// -- Shorthand Parser (for `border`, `border-top`, etc.) --

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq)]

pub enum CssBorderSideParseError<'a> {

    InvalidDeclaration(&'a str),

    Width(CssPixelValueParseError<'a>),

    Style(CssBorderStyleParseError<'a>),

    Color(CssColorParseError<'a>),

}

#[cfg(feature = "parser")]

impl_debug_as_display!(CssBorderSideParseError<'a>);

#[cfg(feature = "parser")]

impl_display! { CssBorderSideParseError<'a>, {

    InvalidDeclaration(e) => format!("Invalid border declaration: \"{}\"", e),

    Width(e) => format!("Invalid border-width component: {}", e),

    Style(e) => format!("Invalid border-style component: {}", e),

    Color(e) => format!("Invalid border-color component: {}", e),

}}

#[cfg(feature = "parser")]

impl_from!(CssPixelValueParseError<'a>, CssBorderSideParseError::Width);

#[cfg(feature = "parser")]

impl_from!(CssBorderStyleParseError<'a>, CssBorderSideParseError::Style);

#[cfg(feature = "parser")]

impl_from!(CssColorParseError<'a>, CssBorderSideParseError::Color);

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssBorderSideParseErrorOwned {

    InvalidDeclaration(AzString),

    Width(CssPixelValueParseErrorOwned),

    Style(CssBorderStyleParseErrorOwned),

    Color(CssColorParseErrorOwned),

}

#[cfg(feature = "parser")]

impl CssBorderSideParseError<'_> {

            }

            }

            }

            }

        }

}

#[cfg(feature = "parser")]

impl CssBorderSideParseErrorOwned {

            }

        }

}

// Type alias for compatibility with old code

#[cfg(feature = "parser")]

pub type CssBorderParseError<'a> = CssBorderSideParseError<'a>;

/// Newtype wrapper around `CssBorderSideParseErrorOwned` for the `border` shorthand.

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq)]

#[repr(C)]

pub struct CssBorderParseErrorOwned {

    pub inner: CssBorderSideParseErrorOwned,

}

#[cfg(feature = "parser")]

impl From<CssBorderSideParseErrorOwned> for CssBorderParseErrorOwned {

}

/// Parses a border shorthand property such as "1px solid red".

/// Handles any order of components and applies defaults for missing values.

#[cfg(feature = "parser")]

        // Try to parse as a width.

        // Try to parse as a style.

        // Try to parse as a color.

        // If we get here, the part didn't match anything, or a value was specified twice.

    }

// --- Individual Property Parsers ---

#[cfg(feature = "parser")]

    }

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-top-width` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-right-width` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-bottom-width` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-left-width` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-top-style` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-right-style` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-bottom-style` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-left-style` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-top-color` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-right-color` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-bottom-color` value.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-left-color` value.

// --- Border Color Shorthand ---

/// Parsed result of `border-color` shorthand (1-4 color values)

#[cfg(feature = "parser")]

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

pub struct StyleBorderColors {

    pub top: ColorU,

    pub right: ColorU,

    pub bottom: ColorU,

    pub left: ColorU,

}

/// Parses `border-color` shorthand: 1-4 color values

/// - 1 value: all sides

/// - 2 values: top/bottom, left/right

/// - 3 values: top, left/right, bottom

/// - 4 values: top, right, bottom, left

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-color` value.

        1 => {

        }

        2 => {

        }

        3 => {

        }

        4 => {

        }

    }

// --- Border Style Shorthand ---

/// Parsed result of `border-style` shorthand (1-4 style values)

#[cfg(feature = "parser")]

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

pub struct StyleBorderStyles {

    pub top: BorderStyle,

    pub right: BorderStyle,

    pub bottom: BorderStyle,

    pub left: BorderStyle,

}

/// Parses `border-style` shorthand: 1-4 style values

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-style` value.

        1 => {

        }

        2 => {

        }

        3 => {

        }

        4 => {

        }

    }

// --- Border Width Shorthand ---

/// Parsed result of `border-width` shorthand (1-4 width values)

#[cfg(feature = "parser")]

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

pub struct StyleBorderWidths {

    pub top: PixelValue,

    pub right: PixelValue,

    pub bottom: PixelValue,

    pub left: PixelValue,

}

/// Parses `border-width` shorthand: 1-4 width values

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border-width` value.

        1 => {

        }

        2 => {

        }

        3 => {

        }

        4 => {

        }

    }

// Compatibility alias

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `border` value.

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

mod tests {

    use super::*;

    #[test]

            BorderStyle::Dashed

        );

    #[test]

        // Full

        // Different order

        // Missing width

        // Missing style

        // Missing color

        // Only one value

    #[test]

        // Two widths

        // Two styles

        // Two colors

        // Empty

        // Unknown keyword

    #[test]

        );

            BorderStyle::Groove

        );

                .inner,

        );

}

#[cfg(test)]

mod autotest_generated {

    use super::*;

    const ALL_STYLES: [BorderStyle; 10] = [

        BorderStyle::None,

        BorderStyle::Solid,

        BorderStyle::Double,

        BorderStyle::Dotted,

        BorderStyle::Dashed,

        BorderStyle::Hidden,

        BorderStyle::Groove,

        BorderStyle::Ridge,

        BorderStyle::Inset,

        BorderStyle::Outset,

    ];

    // =====================================================================

    // BorderStyle: Display / PrintAsCssValue / Default

    // =====================================================================

    #[test]

    fn border_style_display_is_a_unique_lowercase_keyword_for_every_variant() {

        let mut seen: Vec<String> = Vec::new();

        for style in ALL_STYLES {

            let s = style.to_string();

            assert!(!s.is_empty(), "{style:?} renders as the empty string");

            assert!(

                s.chars().all(|c| c.is_ascii_lowercase()),

                "{style:?} renders as {s:?}, which is not a lowercase ASCII keyword"

            );

            assert!(

                !seen.contains(&s),

                "two BorderStyle variants both render as {s:?} (copy-paste in Display)"

            );

            seen.push(s);

        }

        assert_eq!(seen.len(), ALL_STYLES.len());

    }

    #[test]

    fn border_style_print_as_css_value_matches_display() {

        for style in ALL_STYLES {

            assert_eq!(style.print_as_css_value(), style.to_string());

        }

    }

    #[test]

    fn border_style_default_is_none_and_formats_as_none() {

        assert_eq!(BorderStyle::default(), BorderStyle::None);

        assert_eq!(BorderStyle::default().to_string(), "none");

    }

    // =====================================================================

    // Side-property structs: Default / Debug / const_px / interpolate

    // =====================================================================

    #[test]

    fn border_side_property_defaults_match_the_css_initial_values() {

        // border-*-style initial value is `none`

        assert_eq!(StyleBorderTopStyle::default().inner, BorderStyle::None);

        assert_eq!(StyleBorderRightStyle::default().inner, BorderStyle::None);

        assert_eq!(StyleBorderBottomStyle::default().inner, BorderStyle::None);

        assert_eq!(StyleBorderLeftStyle::default().inner, BorderStyle::None);

        // border-*-color has no `currentcolor` here; the documented stand-in is BLACK

        assert_eq!(StyleBorderTopColor::default().inner, ColorU::BLACK);

        assert_eq!(StyleBorderRightColor::default().inner, ColorU::BLACK);

        assert_eq!(StyleBorderBottomColor::default().inner, ColorU::BLACK);

        assert_eq!(StyleBorderLeftColor::default().inner, ColorU::BLACK);

        // border-*-width initial value is `medium` (3px)

        assert_eq!(

            LayoutBorderTopWidth::default().inner,

            MEDIUM_BORDER_THICKNESS

        );

        assert_eq!(

            LayoutBorderRightWidth::default().inner,

            MEDIUM_BORDER_THICKNESS

        );

        assert_eq!(

            LayoutBorderBottomWidth::default().inner,

            MEDIUM_BORDER_THICKNESS

        );

        assert_eq!(

            LayoutBorderLeftWidth::default().inner,

            MEDIUM_BORDER_THICKNESS

        );

        assert_eq!(MEDIUM_BORDER_THICKNESS, PixelValue::px(3.0));

    }

    #[test]

    fn border_side_property_debug_impls_are_the_documented_shapes() {

        // The macro deliberately overrides Debug: styles print the keyword,

        // colors print the 8-digit hash, widths print the pixel value.

        assert_eq!(format!("{:?}", StyleBorderTopStyle::default()), "none");

        assert_eq!(

            format!(

                "{:?}",

                StyleBorderLeftStyle {

                    inner: BorderStyle::Groove

                }

            ),

            "groove"

        );

        assert_eq!(

            format!("{:?}", StyleBorderTopColor::default()),

            "#000000ff"

        );

        assert_eq!(format!("{:?}", LayoutBorderTopWidth::default()), "3px");

    }

    #[test]

    fn layout_border_width_const_px_matches_the_runtime_constructor() {

        assert_eq!(

            LayoutBorderTopWidth::const_px(5).inner,

            PixelValue::px(5.0)

        );

        assert_eq!(LayoutBorderRightWidth::const_px(0).inner, PixelValue::zero());

        assert_eq!(

            LayoutBorderBottomWidth::const_px(-2).inner,

            PixelValue::px(-2.0)

        );

        // The largest magnitude `const_px` can scale by FP_PRECISION_MULTIPLIER

        // (1000) without overflowing the isize multiply. Anything beyond this

        // overflows — see the FloatValue::const_new tests in length.rs.

        let max_safe = isize::MAX / 1000;

        assert!(LayoutBorderLeftWidth::const_px(max_safe)

            .inner

            .number

            .get()

            .is_finite());

    }

    #[test]

    fn layout_border_width_interpolate_endpoints_are_exact() {

        let a = LayoutBorderTopWidth::const_px(0);

        let b = LayoutBorderTopWidth::const_px(10);

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

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

        assert_eq!(a.interpolate(&b, 0.5).inner, PixelValue::px(5.0));

    }

    #[test]

    fn layout_border_width_interpolate_stays_finite_for_hostile_t() {

        let a = LayoutBorderTopWidth::const_px(0);

        let b = LayoutBorderTopWidth::const_px(10);

        for t in [

            0.0,

            1.0,

            -1.0,

            2.0,

            f32::NAN,

            f32::INFINITY,

            f32::NEG_INFINITY,

            f32::MAX,

            f32::MIN,

        ] {

            // A NaN/inf must never leak out of the animation path: FloatValue

            // stores an isize, so the cast saturates instead of propagating.

            assert!(

                a.interpolate(&b, t).inner.number.get().is_finite(),

                "interpolate(t = {t}) produced a non-finite width"

            );

            assert!(b.interpolate(&a, t).inner.number.get().is_finite());

        }

    }

    #[test]

    fn layout_border_width_interpolate_across_metrics_stays_finite() {

        let px = LayoutBorderRightWidth {

            inner: PixelValue::px(4.0),

        };

        let em = LayoutBorderRightWidth {

            inner: PixelValue::em(2.0),

        };

        let percent = LayoutBorderRightWidth {

            inner: PixelValue::percent(100.0),

        };

        for t in [0.0, 0.5, 1.0, -3.0, f32::NAN, f32::INFINITY] {

            assert!(px.interpolate(&em, t).inner.number.get().is_finite());

            assert!(em.interpolate(&percent, t).inner.number.get().is_finite());

            assert!(percent.interpolate(&px, t).inner.number.get().is_finite());

        }

    }

    #[test]

    fn style_border_color_interpolate_endpoints_are_exact() {

        let black = StyleBorderTopColor {

            inner: ColorU::BLACK,

        };

        let white = StyleBorderTopColor {

            inner: ColorU::WHITE,

        };

        assert_eq!(black.interpolate(&white, 0.0).inner, ColorU::BLACK);

        assert_eq!(black.interpolate(&white, 1.0).inner, ColorU::WHITE);

        let mid = black.interpolate(&white, 0.5).inner;

        assert_eq!((mid.r, mid.g, mid.b), (128, 128, 128));

    }

    #[test]

    fn style_border_color_interpolate_hostile_t_does_not_panic() {

        let a = StyleBorderLeftColor {

            inner: ColorU::new(10, 20, 30, 40),

        };

        let b = StyleBorderLeftColor {

            inner: ColorU::new(200, 210, 220, 230),

        };

        for t in [

            -1000.0,

            1000.0,

            f32::NAN,

            f32::INFINITY,

            f32::NEG_INFINITY,

            f32::MAX,

        ] {

            // u8 channels saturate; the only requirement is that this returns.

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

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

        }

    }

    // =====================================================================

    // parse_border_style

    // =====================================================================

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_accepts_every_keyword() {

        assert_eq!(parse_border_style("none").unwrap(), BorderStyle::None);

        assert_eq!(parse_border_style("solid").unwrap(), BorderStyle::Solid);

        assert_eq!(parse_border_style("double").unwrap(), BorderStyle::Double);

        assert_eq!(parse_border_style("dotted").unwrap(), BorderStyle::Dotted);

        assert_eq!(parse_border_style("dashed").unwrap(), BorderStyle::Dashed);

        assert_eq!(parse_border_style("hidden").unwrap(), BorderStyle::Hidden);

        assert_eq!(parse_border_style("groove").unwrap(), BorderStyle::Groove);

        assert_eq!(parse_border_style("ridge").unwrap(), BorderStyle::Ridge);

        assert_eq!(parse_border_style("inset").unwrap(), BorderStyle::Inset);

        assert_eq!(parse_border_style("outset").unwrap(), BorderStyle::Outset);

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_round_trips_through_display() {

        for style in ALL_STYLES {

            let encoded = style.to_string();

            assert_eq!(

                parse_border_style(&encoded).unwrap(),

                style,

                "{encoded} did not round-trip"

            );

            // and through the PrintAsCssValue path, which must agree

            assert_eq!(

                parse_border_style(&style.print_as_css_value()).unwrap(),

                style

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_trims_surrounding_whitespace() {

        for input in [" solid", "solid ", "\t\nsolid\r\n ", "   solid   "] {

            assert_eq!(

                parse_border_style(input).unwrap(),

                BorderStyle::Solid,

                "{input:?} should trim to `solid`"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_empty_and_whitespace_only_are_errors() {

        for input in ["", " ", "   ", "\t", "\n", "\r\n\t "] {

            assert!(

                parse_border_style(input).is_err(),

                "{input:?} must not parse as a border style"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_error_carries_the_untrimmed_input() {

        // The Ok path trims, but the Err path hands back the *raw* input.

        let input = "  bogus  ";

        let err = parse_border_style(input).unwrap_err();

        assert!(

            matches!(err, CssBorderStyleParseError::InvalidStyle(s) if s == input),

            "unexpected error payload: {err:?}"

        );

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_rejects_uppercase_keywords() {

        // NOTE: CSS keywords are ASCII case-insensitive, so a spec-conformant

        // parser would accept these. This parser does not — asserted here so

        // the divergence is visible rather than silent.

        for input in ["SOLID", "Solid", "sOlId", "NONE", "Dashed"] {

            assert!(

                parse_border_style(input).is_err(),

                "{input:?} unexpectedly parsed (case-insensitivity was added?)"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_rejects_garbage_unicode_and_numbers() {

        for input in [

            "solidd",

            "soli",

            "solid solid",

            "solid;garbage",

            "solid!important",

            "0",

            "-0",

            "1px",

            "9223372036854775807",

            "NaN",

            "inf",

            "-inf",

            "\u{1F600}",

            "s\u{0301}olid",

            "sölid",

            "\u{0}",

            "\u{202e}solid",

            "sol\tid",

            "()",

            "solid()",

        ] {

            assert!(

                parse_border_style(input).is_err(),

                "{input:?} unexpectedly parsed as a border style"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_style_handles_huge_and_nested_input_without_panicking() {

        let huge = "a".repeat(100_000);

        assert!(parse_border_style(&huge).is_err());

        let repeated = "solid ".repeat(50_000);

        assert!(parse_border_style(&repeated).is_err());

        let nested = format!("{}{}", "(".repeat(10_000), ")".repeat(10_000));

        assert!(parse_border_style(&nested).is_err());

        let padded = format!("{}solid{}", " ".repeat(100_000), " ".repeat(100_000));

        assert_eq!(parse_border_style(&padded).unwrap(), BorderStyle::Solid);

    }

    // =====================================================================

    // border-*-style longhands

    // =====================================================================

    #[cfg(feature = "parser")]

    #[test]

    fn border_style_longhands_agree_with_parse_border_style() {

        for style in ALL_STYLES {

            let input = style.to_string();

            assert_eq!(parse_border_top_style(&input).unwrap().inner, style);

            assert_eq!(parse_border_right_style(&input).unwrap().inner, style);

            assert_eq!(parse_border_bottom_style(&input).unwrap().inner, style);

            assert_eq!(parse_border_left_style(&input).unwrap().inner, style);

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn border_style_longhands_reject_everything_parse_border_style_rejects() {

        for input in ["", "   ", "SOLID", "solidd", "\u{1F600}", "1px", "solid red"] {

            assert!(parse_border_top_style(input).is_err(), "top: {input:?}");

            assert!(parse_border_right_style(input).is_err(), "right: {input:?}");

            assert!(

                parse_border_bottom_style(input).is_err(),

                "bottom: {input:?}"

            );

            assert!(parse_border_left_style(input).is_err(), "left: {input:?}");

        }

    }

    // =====================================================================

    // parse_border_width_value (private)

    // =====================================================================

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_width_value_accepts_the_three_keywords() {

        assert_eq!(

            parse_border_width_value("thin").unwrap(),

            THIN_BORDER_THICKNESS

        );

        assert_eq!(

            parse_border_width_value("medium").unwrap(),

            MEDIUM_BORDER_THICKNESS

        );

        assert_eq!(

            parse_border_width_value("thick").unwrap(),

            THICK_BORDER_THICKNESS

        );

        // keywords are trimmed like everything else

        assert_eq!(

            parse_border_width_value("  \tthick\n ").unwrap(),

            THICK_BORDER_THICKNESS

        );

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_width_value_rejects_uppercase_keywords() {

        // Same case-sensitivity divergence as parse_border_style.

        for input in ["THIN", "Medium", "THICK"] {

            assert!(

                parse_border_width_value(input).is_err(),

                "{input:?} unexpectedly parsed"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_width_value_empty_and_whitespace_only_are_errors() {

        for input in ["", " ", "\t\n", "    "] {

            let err = parse_border_width_value(input).unwrap_err();

            assert!(

                matches!(err, CssPixelValueParseError::EmptyString),

                "{input:?} -> {err:?}"

            );

        }

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_width_value_bare_number_is_interpreted_as_px() {

        assert_eq!(parse_border_width_value("0").unwrap(), PixelValue::px(0.0));

        assert_eq!(parse_border_width_value("42").unwrap(), PixelValue::px(42.0));

        assert_eq!(

            parse_border_width_value("1.5").unwrap(),

            PixelValue::px(1.5)

        );

        // -0 collapses to +0 once quantized into the isize-backed FloatValue

        assert_eq!(parse_border_width_value("-0").unwrap(), PixelValue::px(0.0));

        // negative widths are *accepted* (CSS would reject them) — pinned so a

        // future validity check is a deliberate change, not an accident.

        assert_eq!(

            parse_border_width_value("-5px").unwrap(),

            PixelValue::px(-5.0)

        );

    }

    #[cfg(feature = "parser")]

    #[test]

    fn parse_border_width_value_nan_saturates_to_zero() {

        // "NaN" is a valid f32 literal for Rust's FromStr, so this reaches

        // FloatValue::new(NaN) — which saturates to 0 rather than storing NaN.

        let parsed = parse_border_width_value("NaN").unwrap();