//! CSS properties for table layout and styling.

//!

//! This module contains properties specific to CSS table formatting:

//! - `table-layout`: Controls the algorithm used to layout table cells, rows, and columns

//! - `border-collapse`: Specifies whether cell borders are collapsed into a single border or

//!   separated

//! - `border-spacing`: Sets the distance between borders of adjacent cells (separate borders only)

//! - `caption-side`: Specifies the placement of a table caption

//! - `empty-cells`: Specifies whether or not to display borders on empty cells in a table

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

use crate::{

    codegen::format::FormatAsRustCode,

    props::{

        basic::pixel::{CssPixelValueParseError, PixelValue},

        formatter::PrintAsCssValue,

    },

};

// table-layout

/// Controls the algorithm used to lay out table cells, rows, and columns.

///

/// The `table-layout` property determines whether the browser should use:

/// - **auto**: Column widths are determined by the content (slower but flexible)

/// - **fixed**: Column widths are determined by the first row (faster and predictable)

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

#[repr(C)]

#[derive(Default)]

pub enum LayoutTableLayout {

    /// Use automatic table layout algorithm (content-based, default).

    /// Column width is set by the widest unbreakable content in the cells.

    #[default]

    Auto,

    /// Use fixed table layout algorithm (first-row-based).

    /// Column width is set by the width property of the column or first-row cell.

    /// Renders faster than auto.

    Fixed,

}

impl PrintAsCssValue for LayoutTableLayout {

        }

}

impl FormatAsRustCode for LayoutTableLayout {

        }

}

// border-collapse

/// Specifies whether cell borders are collapsed into a single border or separated.

///

/// The `border-collapse` property determines the border rendering model:

/// - **separate**: Each cell has its own border (default, uses border-spacing)

/// - **collapse**: Adjacent cells share borders (ignores border-spacing)

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

#[repr(C)]

#[derive(Default)]

pub enum StyleBorderCollapse {

    /// Borders are separated (default). Each cell has its own border.

    /// The `border-spacing` property defines the distance between borders.

    #[default]

    Separate,

    /// Borders are collapsed. Adjacent cells share a single border.

    /// Border conflict resolution rules apply when borders differ.

    Collapse,

}

impl PrintAsCssValue for StyleBorderCollapse {

        }

}

impl FormatAsRustCode for StyleBorderCollapse {

        }

}

// border-spacing

/// Sets the distance between the borders of adjacent cells.

///

/// The `border-spacing` property is only applicable when `border-collapse` is set to `separate`.

/// It can have one or two values:

/// - One value: Sets both horizontal and vertical spacing

/// - Two values: First is horizontal, second is vertical

///

/// This struct represents a single spacing value (either horizontal or vertical).

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

#[repr(C)]

pub struct LayoutBorderSpacing {

    /// Horizontal spacing between cell borders

    pub horizontal: PixelValue,

    /// Vertical spacing between cell borders

    pub vertical: PixelValue,

}

impl Default for LayoutBorderSpacing {

        // Default border-spacing is 0 (no spacing)

}

impl LayoutBorderSpacing {

    /// Creates a new border spacing with the same value for horizontal and vertical

    /// Creates a new border spacing with different horizontal and vertical values

}

impl PrintAsCssValue for LayoutBorderSpacing {

            // Single value: same for both dimensions

        } else {

            // Two values: horizontal vertical

        }

}

impl FormatAsRustCode for LayoutBorderSpacing {

        use crate::codegen::format::format_pixel_value;

        )

}

// caption-side

/// Specifies the placement of a table caption.

///

/// The `caption-side` property positions the caption either above or below the table.

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

#[repr(C)]

#[derive(Default)]

pub enum StyleCaptionSide {

    /// Caption is placed above the table (default)

    #[default]

    Top,

    /// Caption is placed below the table

    Bottom,

}

impl PrintAsCssValue for StyleCaptionSide {

        }

}

impl FormatAsRustCode for StyleCaptionSide {

        }

}

// empty-cells

/// Specifies whether or not to display borders and background on empty cells.

///

/// The `empty-cells` property only applies when `border-collapse` is set to `separate`.

/// A cell is considered empty if it contains no visible content.

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

#[repr(C)]

#[derive(Default)]

pub enum StyleEmptyCells {

    /// Show borders and background on empty cells (default)

    #[default]

    Show,

    /// Hide borders and background on empty cells

    Hide,

}

impl PrintAsCssValue for StyleEmptyCells {

        }

}

impl FormatAsRustCode for StyleEmptyCells {

        }

}

// Parsing Functions

/// Parse errors for table-layout property

#[derive(Debug, Clone, PartialEq)]

pub(crate) enum LayoutTableLayoutParseError<'a> {

    InvalidKeyword(&'a str),

}

/// Parse a table-layout value from a string

    }

/// Parse errors for border-collapse property

#[derive(Debug, Clone, PartialEq)]

pub(crate) enum StyleBorderCollapseParseError<'a> {

    InvalidKeyword(&'a str),

}

/// Parse a border-collapse value from a string

    }

/// Parse errors for border-spacing property

#[derive(Debug, Clone, PartialEq)]

pub(crate) enum LayoutBorderSpacingParseError<'a> {

    PixelValue(CssPixelValueParseError<'a>),

    InvalidFormat,

}

/// Parse a border-spacing value from a string

/// Accepts: "5px" or "5px 10px"

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

        1 => {

            // Single value: use for both horizontal and vertical

        }

        2 => {

            // Two values: horizontal vertical

        }

    }

/// Parse errors for caption-side property

#[derive(Debug, Clone, PartialEq)]

pub(crate) enum StyleCaptionSideParseError<'a> {

    InvalidKeyword(&'a str),

}

/// Parse a caption-side value from a string

    }

/// Parse errors for empty-cells property

#[derive(Debug, Clone, PartialEq)]

pub(crate) enum StyleEmptyCellsParseError<'a> {

    InvalidKeyword(&'a str),

}

/// Parse an empty-cells value from a string

    }

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

            LayoutTableLayout::Fixed

        );

    #[test]

            StyleBorderCollapse::Separate

        );

            StyleBorderCollapse::Collapse

        );

    #[test]

    #[test]

            StyleCaptionSide::Bottom

        );

    #[test]

}

#[cfg(test)]

#[allow(clippy::float_cmp)] // exact comparisons are the point: FloatValue is fixed-point

mod autotest_generated {

    use crate::props::basic::SizeMetric;

    use super::*;

    // `FloatValue` stores millipixels in an `isize` (value * 1000, truncated via

    // `as`). `.number.number()` is that raw integer -- asserting on it keeps the

    // numeric tests exact instead of comparing floats.

    fn raw(p: PixelValue) -> isize {

        p.number.number()

    }

    fn table_layout_ok(s: &str) -> bool {

        parse_table_layout(s).is_ok()

    }

    fn border_collapse_ok(s: &str) -> bool {

        parse_border_collapse(s).is_ok()

    }

    fn caption_side_ok(s: &str) -> bool {

        parse_caption_side(s).is_ok()

    }

    fn empty_cells_ok(s: &str) -> bool {

        parse_empty_cells(s).is_ok()

    }

    /// Every keyword parser, type-erased to `&str -> bool` (is it accepted?), so

    /// the malformed-input cases can be asserted against all four at once.

    type KeywordParser = (&'static str, fn(&str) -> bool);

    const KEYWORD_PARSERS: &[KeywordParser] = &[

        ("table-layout", table_layout_ok),

        ("border-collapse", border_collapse_ok),

        ("caption-side", caption_side_ok),

        ("empty-cells", empty_cells_ok),

    ];

    fn assert_all_keyword_parsers_reject(input: &str, why: &str) {

        for (prop, parse) in KEYWORD_PARSERS {

            assert!(

                !parse(input),

                "{prop}: expected {input:?} to be rejected ({why}), but it parsed"

            );

        }

    }

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

    // constructors

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

    #[test]

    fn new_applies_the_same_spacing_to_both_axes() {

        let s = LayoutBorderSpacing::new(PixelValue::const_px(7));

        assert_eq!(s.horizontal, PixelValue::const_px(7));

        assert_eq!(s.vertical, PixelValue::const_px(7));

        assert_eq!(s.horizontal, s.vertical);

    }

    #[test]

    fn new_separate_preserves_argument_order() {

        // Asymmetric on purpose: a swapped assignment would still pass if both

        // axes shared a metric *and* a value.

        let s = LayoutBorderSpacing::new_separate(

            PixelValue::const_px(3),

            PixelValue::percent(50.0),

        );

        assert_eq!(s.horizontal, PixelValue::const_px(3));

        assert_eq!(s.vertical, PixelValue::percent(50.0));

        assert_ne!(s.horizontal, s.vertical);

    }

    #[test]

    fn constructors_do_not_panic_on_extreme_floats() {

        let extremes = [

            0.0f32,

            -0.0,

            1.0,

            -1.0,

            f32::EPSILON,

            f32::MIN_POSITIVE,

            -f32::MIN_POSITIVE,

            f32::MAX,

            f32::MIN,

            f32::INFINITY,

            f32::NEG_INFINITY,

            f32::NAN,

        ];

        for v in extremes {

            let same = LayoutBorderSpacing::new(PixelValue::px(v));

            assert_eq!(same.horizontal, same.vertical, "new({v}) must be symmetric");

            for w in extremes {

                let sep =

                    LayoutBorderSpacing::new_separate(PixelValue::px(v), PixelValue::em(w));

                assert_eq!(sep.horizontal.metric, SizeMetric::Px);

                assert_eq!(sep.vertical.metric, SizeMetric::Em);

                // Whatever the input float was, the stored value is a plain isize,

                // so it can never be NaN/inf once it lands in the struct.

                assert!(sep.horizontal.number.get().is_finite());

                assert!(sep.vertical.number.get().is_finite());

            }

        }

    }

    #[test]

    fn nan_spacing_is_flattened_to_zero_and_stays_comparable() {

        // `FloatValue::new` does `NaN * 1000.0 as isize`, and an `as` cast maps NaN

        // to 0. So a NaN spacing silently becomes 0px rather than poisoning Eq/Ord

        // (which are derived over the isize, not the float).

        let nan = LayoutBorderSpacing::new(PixelValue::px(f32::NAN));

        assert_eq!(raw(nan.horizontal), 0);

        assert_eq!(raw(nan.vertical), 0);

        // Reflexivity would fail here if equality were float-based.

        assert_eq!(nan, nan);

        assert_eq!(nan, LayoutBorderSpacing::new(PixelValue::px(f32::NAN)));

        assert_eq!(nan, LayoutBorderSpacing::new(PixelValue::px(0.0)));

        assert_eq!(nan, LayoutBorderSpacing::default());

    }

    #[test]

    fn infinite_spacing_saturates_instead_of_wrapping() {

        // `inf * 1000.0 as isize` saturates at the isize bounds; ditto any finite

        // f32 whose *1000 scaling overflows (f32::MAX).

        for input in [f32::INFINITY, f32::MAX, 1e38] {

            let s = LayoutBorderSpacing::new(PixelValue::px(input));

            assert_eq!(raw(s.horizontal), isize::MAX, "{input} must saturate high");

            assert!(s.horizontal.number.get().is_finite());

        }

        for input in [f32::NEG_INFINITY, f32::MIN, -1e38] {

            let s = LayoutBorderSpacing::new(PixelValue::px(input));

            assert_eq!(raw(s.horizontal), isize::MIN, "{input} must saturate low");

            assert!(s.horizontal.number.get().is_finite());

        }

    }

    #[test]

    fn equal_border_spacings_hash_equal() {

        use std::{

            collections::hash_map::DefaultHasher,

            hash::{Hash, Hasher},

        };

        fn hash(s: LayoutBorderSpacing) -> u64 {

            let mut h = DefaultHasher::new();

            s.hash(&mut h);

            h.finish()

        }

        // NaN and 0.0 collapse to the same stored value, so the Hash/Eq contract

        // must hold across them too.

        assert_eq!(

            hash(LayoutBorderSpacing::new(PixelValue::px(f32::NAN))),

            hash(LayoutBorderSpacing::default())

        );

        assert_eq!(

            hash(LayoutBorderSpacing::new(PixelValue::const_px(4))),

            hash(LayoutBorderSpacing::new_separate(

                PixelValue::const_px(4),

                PixelValue::const_px(4)

            ))

        );

    }

    #[test]

    fn defaults_are_the_css_initial_values() {

        assert_eq!(LayoutTableLayout::default(), LayoutTableLayout::Auto);

        assert_eq!(StyleBorderCollapse::default(), StyleBorderCollapse::Separate);

        assert_eq!(StyleCaptionSide::default(), StyleCaptionSide::Top);

        assert_eq!(StyleEmptyCells::default(), StyleEmptyCells::Show);

        let d = LayoutBorderSpacing::default();

        assert_eq!(d, LayoutBorderSpacing::new(PixelValue::const_px(0)));

        assert_eq!(raw(d.horizontal), 0);

        assert_eq!(raw(d.vertical), 0);

        assert_eq!(d.horizontal.metric, SizeMetric::Px);

    }

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

    // keyword parsers: table-layout / border-collapse / caption-side / empty-cells

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

    #[test]

    fn keyword_parsers_accept_every_variant() {

        // Positive controls -- exhaustive over the variants of each enum.

        assert_eq!(parse_table_layout("auto").unwrap(), LayoutTableLayout::Auto);

        assert_eq!(parse_table_layout("fixed").unwrap(), LayoutTableLayout::Fixed);

        assert_eq!(

            parse_border_collapse("separate").unwrap(),

            StyleBorderCollapse::Separate

        );

        assert_eq!(

            parse_border_collapse("collapse").unwrap(),

            StyleBorderCollapse::Collapse

        );

        assert_eq!(parse_caption_side("top").unwrap(), StyleCaptionSide::Top);

        assert_eq!(parse_caption_side("bottom").unwrap(), StyleCaptionSide::Bottom);

        assert_eq!(parse_empty_cells("show").unwrap(), StyleEmptyCells::Show);

        assert_eq!(parse_empty_cells("hide").unwrap(), StyleEmptyCells::Hide);

    }

    #[test]

    fn keyword_parsers_reject_empty_input() {

        assert_all_keyword_parsers_reject("", "empty input");

        assert_eq!(

            parse_table_layout(""),

            Err(LayoutTableLayoutParseError::InvalidKeyword(""))

        );

        assert_eq!(

            parse_border_collapse(""),

            Err(StyleBorderCollapseParseError::InvalidKeyword(""))

        );

        assert_eq!(

            parse_caption_side(""),

            Err(StyleCaptionSideParseError::InvalidKeyword(""))

        );

        assert_eq!(

            parse_empty_cells(""),

            Err(StyleEmptyCellsParseError::InvalidKeyword(""))

        );

    }

    #[test]

    fn keyword_parsers_reject_whitespace_only_input() {

        for input in ["   ", "\t", "\n", "\r\n", "\t\n \x0c", "\u{a0}", "\u{2028}"] {

            assert_all_keyword_parsers_reject(input, "whitespace only");

        }

        // The trim happens before the match, so the error payload is the *trimmed*

        // input -- i.e. the empty string, not the original blanks.

        assert_eq!(

            parse_table_layout("  \t\n "),

            Err(LayoutTableLayoutParseError::InvalidKeyword(""))

        );

    }

    #[test]

    fn keyword_parsers_trim_surrounding_whitespace() {

        assert_eq!(

            parse_table_layout("   auto\t\n").unwrap(),

            LayoutTableLayout::Auto

        );

        assert_eq!(

            parse_border_collapse("\r\n collapse  ").unwrap(),

            StyleBorderCollapse::Collapse

        );

        assert_eq!(

            parse_caption_side("\t bottom \t").unwrap(),

            StyleCaptionSide::Bottom

        );

        assert_eq!(parse_empty_cells("\n hide \n").unwrap(), StyleEmptyCells::Hide);

    }

    #[test]

    fn keyword_parsers_also_trim_non_css_unicode_whitespace() {

        // Characterized leniency: `str::trim` strips everything with the Unicode

        // White_Space property, but CSS whitespace is only space/tab/LF/CR/FF. So

        // NBSP- and LINE-SEPARATOR-padded keywords are accepted here even though a

        // conformant tokenizer would reject them.

        assert_eq!(

            parse_table_layout("\u{a0}auto\u{a0}").unwrap(),

            LayoutTableLayout::Auto

        );

        assert_eq!(

            parse_empty_cells("\u{2028}show\u{2029}").unwrap(),

            StyleEmptyCells::Show

        );

    }

    #[test]

    fn keyword_parse_errors_carry_the_trimmed_input() {

        // The error borrows from `input` (lifetime-tied) and reports the trimmed

        // slice, not the raw one.

        assert_eq!(

            parse_table_layout("  bogus  "),

            Err(LayoutTableLayoutParseError::InvalidKeyword("bogus"))

        );

        assert_eq!(

            parse_border_collapse(" separate collapse "),

            Err(StyleBorderCollapseParseError::InvalidKeyword(

                "separate collapse"

            ))

        );

        assert_eq!(

            parse_caption_side("\ttop;\t"),

            Err(StyleCaptionSideParseError::InvalidKeyword("top;"))

        );

        assert_eq!(

            parse_empty_cells(" show hide "),

            Err(StyleEmptyCellsParseError::InvalidKeyword("show hide"))

        );

    }

    #[test]

    fn keyword_parsers_are_case_sensitive() {

        // Conformance gap (characterized, matching `parse_pixel_value`): CSS

        // keywords are ASCII case-insensitive, so `table-layout: AUTO` is valid CSS

        // -- but the match arms only cover the lowercase spelling.

        for input in [

            "AUTO", "Auto", "aUtO", "FIXED", "SEPARATE", "Collapse", "TOP", "Bottom",

            "SHOW", "Hide",

        ] {

            assert_all_keyword_parsers_reject(input, "keyword matching is case-sensitive");

        }

    }

    #[test]

    fn keyword_parsers_reject_garbage() {

        for input in [

            "invalid",

            "auto fixed",

            "auto;",

            "auto;garbage",

            "auto/*c*/",

            "/*auto*/",

            "au to",

            "a\0uto",

            "\0",

            "\u{7f}",

            "-->",

            "<!--",

            "!important",

            "\\61 uto",

            "'auto'",

            "\"auto\"",

            "auto()",

            "url(auto)",

        ] {

            assert_all_keyword_parsers_reject(input, "garbage");

        }

    }

    #[test]

    fn keyword_parsers_reject_boundary_numeric_strings() {

        // None of these properties take a number; the numeric boundary cases must

        // not be coerced into a keyword.

        for input in [

            "0",

            "-0",

            "0.0",

            "1",

            "-1",

            "9223372036854775807",  // i64::MAX

            "-9223372036854775808", // i64::MIN

            "18446744073709551616", // u64::MAX + 1

            "1e400",

            "-1e400",

            "3.4028235e38",

            "1.17549435e-38",

            "NaN",

            "nan",

            "inf",

            "-inf",

            "infinity",

        ] {

            assert_all_keyword_parsers_reject(input, "numeric input for a keyword property");

        }

    }

    #[test]

    fn keyword_parsers_reject_leading_and_trailing_junk() {

        assert_all_keyword_parsers_reject("xauto", "leading junk");

        assert_all_keyword_parsers_reject("autox", "trailing junk");

        assert_all_keyword_parsers_reject("auto!", "trailing junk");

        assert_all_keyword_parsers_reject("(fixed)", "wrapped in parens");

        assert_all_keyword_parsers_reject("collapse,", "trailing comma");

        // Trailing/leading *whitespace* is the one thing that is trimmed away.

        assert_eq!(parse_table_layout("auto ").unwrap(), LayoutTableLayout::Auto);

    }

    #[test]

    fn keyword_parsers_survive_unicode_input() {

        for input in [

            "\u{1F600}",             // emoji

            "auto\u{0301}",          // combining acute on the final char

            "\u{FF41}\u{FF55}\u{FF54}\u{FF4F}", // fullwidth "auto"

            "\u{202E}auto",          // RTL override prefix

            "\u{FEFF}auto",          // BOM prefix (not Unicode whitespace)

            "аuto",                  // leading CYRILLIC A homoglyph

            "🇩🇪",                    // regional indicator pair

            "e\u{0301}\u{0301}\u{0301}",

            "\u{10FFFF}",            // highest scalar value

        ] {

            assert_all_keyword_parsers_reject(input, "non-ASCII input");

        }

        // Slicing must stay on char boundaries: the error payload borrows the input.

        assert_eq!(

            parse_table_layout("  \u{1F600}  "),

            Err(LayoutTableLayoutParseError::InvalidKeyword("\u{1F600}"))

        );

    }

    #[test]

    fn keyword_parsers_survive_extremely_long_input() {

        let long = "a".repeat(1_000_000);

        assert_all_keyword_parsers_reject(&long, "1M-char input");

        assert_eq!(

            parse_table_layout(&long),

            Err(LayoutTableLayoutParseError::InvalidKeyword(long.as_str()))

        );

        // A million repetitions of a *valid* token is still not the token.

        let repeated = "auto".repeat(250_000);

        assert_all_keyword_parsers_reject(&repeated, "repeated valid token");

        // Padding a valid keyword with a megabyte of whitespace still parses.

        let padded = format!("{}auto{}", " ".repeat(500_000), "\n".repeat(500_000));

        assert_eq!(parse_table_layout(&padded).unwrap(), LayoutTableLayout::Auto);

    }

    #[test]

    fn keyword_parsers_survive_deeply_nested_input() {

        // These parsers are non-recursive, so 10k nesting levels must not blow the

        // stack -- assert that explicitly so a future recursive-descent rewrite of

        // the value parser trips here.

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

        assert_all_keyword_parsers_reject(&nested, "10k nested brackets");

        let braces = "{".repeat(50_000);

        assert_all_keyword_parsers_reject(&braces, "50k open braces");

    }

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

    // border-spacing

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

    #[test]

    fn border_spacing_single_value_applies_to_both_axes() {

        let s = parse_border_spacing("5px").unwrap();

        assert_eq!(s.horizontal, PixelValue::const_px(5));

        assert_eq!(s.vertical, PixelValue::const_px(5));

        assert_eq!(s, LayoutBorderSpacing::new(PixelValue::const_px(5)));

    }

    #[test]

    fn border_spacing_two_values_are_horizontal_then_vertical() {

        let s = parse_border_spacing("5px 10px").unwrap();

        assert_eq!(s.horizontal, PixelValue::const_px(5));

        assert_eq!(s.vertical, PixelValue::const_px(10));

        // Order matters: the reversed input must not compare equal.

        assert_ne!(s, parse_border_spacing("10px 5px").unwrap());

    }

    #[test]

    fn border_spacing_accepts_mixed_metrics_per_axis() {

        let s = parse_border_spacing("1em 50%").unwrap();

        assert_eq!(s.horizontal.metric, SizeMetric::Em);

        assert_eq!(raw(s.horizontal), 1000);

        assert_eq!(s.vertical.metric, SizeMetric::Percent);

        assert_eq!(raw(s.vertical), 50_000);

        // "rem" must win over "em" in the suffix table.

        assert_eq!(

            parse_border_spacing("2rem").unwrap().horizontal.metric,

            SizeMetric::Rem

        );

        // ...and "vmax"/"vmin" over "vw"/"vh".

        assert_eq!(

            parse_border_spacing("2vmax 3vmin").unwrap().horizontal.metric,

            SizeMetric::Vmax

        );

    }

    #[test]

    fn border_spacing_rejects_empty_and_whitespace_only_input() {

        // `split_whitespace` yields zero parts, which falls through to the `_` arm.

        for input in ["", "   ", "\t\n", "\r\n\x0c ", "\u{a0}", "\u{2028}\u{2029}"] {

            assert_eq!(

                parse_border_spacing(input),

                Err(LayoutBorderSpacingParseError::InvalidFormat),

                "expected InvalidFormat for {input:?}"

            );

        }

    }

    #[test]

    fn border_spacing_rejects_more_than_two_components() {

        for input in ["5px 10px 15px", "1px 2px 3px 4px", "0 0 0"] {

            assert_eq!(

                parse_border_spacing(input),

                Err(LayoutBorderSpacingParseError::InvalidFormat),

                "expected InvalidFormat for {input:?}"

            );

        }

    }

    #[test]

    fn border_spacing_collapses_arbitrary_internal_whitespace() {

        let expected = LayoutBorderSpacing::new_separate(

            PixelValue::const_px(5),

            PixelValue::const_px(10),

        );

        for input in [

            "5px 10px",

            "  5px   10px  ",

            "\t5px\n10px\r\n",

            "5px\x0c10px",

        ] {

            assert_eq!(parse_border_spacing(input).unwrap(), expected, "{input:?}");

        }

    }

    #[test]

    fn border_spacing_splits_on_non_css_unicode_whitespace() {

        // Characterized leniency (same root cause as the keyword trim):

        // `split_whitespace` uses the Unicode White_Space property, so a

        // non-breaking space separates the two components even though CSS would

        // tokenize `5px\u{a0}10px` as a single (invalid) dimension token.

        let s = parse_border_spacing("5px\u{a0}10px").unwrap();

        assert_eq!(s.horizontal, PixelValue::const_px(5));

        assert_eq!(s.vertical, PixelValue::const_px(10));

    }

    #[test]

    fn border_spacing_propagates_pixel_value_errors() {

        // Unit with no number.

        assert!(matches!(

            parse_border_spacing("px"),

            Err(LayoutBorderSpacingParseError::PixelValue(

                CssPixelValueParseError::NoValueGiven("px", SizeMetric::Px)

            ))

        ));

        // Garbage, unknown unit, trailing junk.

        for input in ["abc", "5foo", "5px;", "#5px", "5 .. px"] {

            assert!(

                parse_border_spacing(input).is_err(),

                "expected {input:?} to be rejected"

            );

        }

        // A separated unit makes the *second* component the failing one.

        assert!(matches!(

            parse_border_spacing("5 px"),

            Err(LayoutBorderSpacingParseError::PixelValue(

                CssPixelValueParseError::NoValueGiven("px", SizeMetric::Px)

            ))

        ));

        // The error payload borrows the offending slice, not the whole input.

        assert!(matches!(

            parse_border_spacing("5px zzz"),

            Err(LayoutBorderSpacingParseError::PixelValue(

                CssPixelValueParseError::InvalidPixelValue("zzz")

            ))

        ));

    }

    #[test]

    fn border_spacing_accepts_unitless_numbers() {

        // Characterized gap: `parse_pixel_value` falls back to a bare f32 and

        // assumes px, so `border-spacing: 5` is accepted as 5px. Per CSS, only a

        // unitless *zero* is legal for a <length>.

        assert_eq!(

            parse_border_spacing("0").unwrap(),

            LayoutBorderSpacing::new(PixelValue::const_px(0))

        );

        assert_eq!(

            parse_border_spacing("5").unwrap(),

            LayoutBorderSpacing::new(PixelValue::const_px(5))

        );

        // -0 must land on the same stored value as +0 (no signed-zero surprises).

        assert_eq!(raw(parse_border_spacing("-0").unwrap().horizontal), 0);

        assert_eq!(

            parse_border_spacing("-0").unwrap(),

            parse_border_spacing("0").unwrap()

        );

    }

    #[test]

    fn border_spacing_accepts_negative_values() {

        // Characterized gap: `border-spacing` is a non-negative <length> in CSS,

        // but nothing here clamps -- the negative value is stored as-is.

        let s = parse_border_spacing("-5px -10px").unwrap();

        assert_eq!(raw(s.horizontal), -5000);

        assert_eq!(raw(s.vertical), -10_000);

    }

    #[test]

    fn border_spacing_flattens_nan_to_zero() {

        // "NaN" is a valid f32 literal, so this reaches `FloatValue::new(NaN)`,

        // where `NaN * 1000.0 as isize` yields 0. The parse succeeds with 0px --

        // it does not panic, and it does not store a NaN.

        let s = parse_border_spacing("NaNpx").unwrap();

        assert_eq!(raw(s.horizontal), 0);

        assert_eq!(raw(s.vertical), 0);

        assert!(s.horizontal.number.get().is_finite());

        assert_eq!(s, LayoutBorderSpacing::default());

        let mixed = parse_border_spacing("NaNpx 4px").unwrap();

        assert_eq!(raw(mixed.horizontal), 0);

        assert_eq!(raw(mixed.vertical), 4000);

    }

    #[test]

    fn border_spacing_saturates_infinite_and_overflowing_values() {

        // Both an explicit infinity and a finite-but-overflowing literal (whose

        // *1000 scaling overflows isize) must saturate rather than wrap.

        for input in ["infpx", "infinitypx", "1e40px", "3.5e38px"] {

            let s = parse_border_spacing(input).unwrap();

            assert_eq!(raw(s.horizontal), isize::MAX, "{input} must saturate high");

            assert!(s.horizontal.number.get().is_finite(), "{input} must be finite");

        }

        for input in ["-infpx", "-1e40px", "-3.5e38px"] {

            let s = parse_border_spacing(input).unwrap();

            assert_eq!(raw(s.horizontal), isize::MIN, "{input} must saturate low");

            assert!(s.horizontal.number.get().is_finite(), "{input} must be finite");

        }

        // Saturation is per-axis, and the high/low bounds do not collapse together.

        let s = parse_border_spacing("infpx -infpx").unwrap();

        assert_eq!(raw(s.horizontal), isize::MAX);

        assert_eq!(raw(s.vertical), isize::MIN);

        assert_ne!(s.horizontal, s.vertical);

    }

    #[test]

    fn border_spacing_truncates_below_milli_precision() {

        // FloatValue is fixed-point with 3 decimals and truncates (does not round)

        // toward zero, so sub-millipixel input silently becomes 0.

        assert_eq!(raw(parse_border_spacing("0.0005px").unwrap().horizontal), 0);

        assert_eq!(raw(parse_border_spacing("0.9999px").unwrap().horizontal), 999);

        assert_eq!(raw(parse_border_spacing("1.9999px").unwrap().horizontal), 1999);

        // Denormal input must not panic or produce a non-finite stored value.

        let denormal = parse_border_spacing("1.17549435e-38px").unwrap();

        assert_eq!(raw(denormal.horizontal), 0);

    }

    #[test]

    fn border_spacing_survives_extremely_long_input() {

        // One 1M-char token: rejected by the pixel parser, and the error borrows

        // the whole slice back out.

        let long_token = "z".repeat(1_000_000);

        assert!(parse_border_spacing(&long_token).is_err());

        // 200k components: hits the `_ => InvalidFormat` arm without hanging.

        let many = "5px ".repeat(200_000);

        assert_eq!(

            parse_border_spacing(&many),

            Err(LayoutBorderSpacingParseError::InvalidFormat)

        );

        // A megabyte of padding around a valid single value still parses.

        let padded = format!("{}5px{}", " ".repeat(500_000), " ".repeat(500_000));

        assert_eq!(

            parse_border_spacing(&padded).unwrap(),

            LayoutBorderSpacing::new(PixelValue::const_px(5))

        );

    }

    #[test]

    fn border_spacing_survives_deeply_nested_input() {

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

        assert!(

            parse_border_spacing(&nested).is_err(),

            "10k nested brackets must be rejected, not stack-overflow"

        );

    }

    #[test]

    fn border_spacing_unicode_input_does_not_panic() {

        for input in [

            "\u{1F600}",

            "5\u{1F600}px",

            "5px \u{1F600}",

            "５px",       // fullwidth digit

            "5\u{0301}px", // combining mark between number and unit

            "\u{FEFF}5px", // BOM prefix (not whitespace -> part of the token)

        ] {

            assert!(

                parse_border_spacing(input).is_err(),

                "expected {input:?} to be rejected"

            );

        }

    }

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

    // round-trips: print_as_css_value -> parse_* must be the identity

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

    #[test]

    fn keyword_enums_roundtrip_through_css() {

        for v in [LayoutTableLayout::Auto, LayoutTableLayout::Fixed] {

            assert_eq!(parse_table_layout(&v.print_as_css_value()).unwrap(), v);

        }

        for v in [StyleBorderCollapse::Separate, StyleBorderCollapse::Collapse] {

            assert_eq!(parse_border_collapse(&v.print_as_css_value()).unwrap(), v);

        }

        for v in [StyleCaptionSide::Top, StyleCaptionSide::Bottom] {

            assert_eq!(parse_caption_side(&v.print_as_css_value()).unwrap(), v);

        }

        for v in [StyleEmptyCells::Show, StyleEmptyCells::Hide] {

            assert_eq!(parse_empty_cells(&v.print_as_css_value()).unwrap(), v);

        }

        // Defaults round-trip too.

        assert_eq!(

            parse_table_layout(&LayoutTableLayout::default().print_as_css_value()).unwrap(),

            LayoutTableLayout::default()

        );

    }

    #[test]

    fn keyword_enum_css_spellings_are_distinct() {

        // A copy-paste in `print_as_css_value` would make two variants print the

        // same string, which the round-trip above would silently accept for one of

        // them.

        assert_ne!(

            LayoutTableLayout::Auto.print_as_css_value(),

            LayoutTableLayout::Fixed.print_as_css_value()

        );

        assert_ne!(

            StyleBorderCollapse::Separate.print_as_css_value(),

            StyleBorderCollapse::Collapse.print_as_css_value()

        );

        assert_ne!(

            StyleCaptionSide::Top.print_as_css_value(),

            StyleCaptionSide::Bottom.print_as_css_value()

        );

        assert_ne!(

            StyleEmptyCells::Show.print_as_css_value(),

            StyleEmptyCells::Hide.print_as_css_value()

        );

    }

    #[test]

    fn border_spacing_roundtrips_through_css() {

        let values = [

            PixelValue::const_px(0),

            PixelValue::const_px(5),

            PixelValue::const_px(-5),

            PixelValue::px(1.5),

            PixelValue::px(-0.125),

            PixelValue::em(2.0),

            PixelValue::rem(0.5),

            PixelValue::percent(50.0),

            PixelValue::from_metric(SizeMetric::Pt, 12.0),

            PixelValue::from_metric(SizeMetric::Vmin, 3.25),

        ];

        for h in values {

            // Single-value form (horizontal == vertical).

            let same = LayoutBorderSpacing::new(h);

            assert_eq!(

                parse_border_spacing(&same.print_as_css_value()).unwrap(),

                same,

                "single-value round-trip failed for {h:?}"

            );

            // Two-value form.

            for v in values {

                let sep = LayoutBorderSpacing::new_separate(h, v);

                assert_eq!(

                    parse_border_spacing(&sep.print_as_css_value()).unwrap(),

                    sep,

                    "two-value round-trip failed for {h:?} / {v:?}"

                );

            }

        }

    }

    #[test]

    fn border_spacing_prints_one_value_only_when_both_axes_match() {

        assert_eq!(

            LayoutBorderSpacing::new(PixelValue::const_px(5)).print_as_css_value(),

            "5px"

        );

        assert_eq!(

            LayoutBorderSpacing::new_separate(

                PixelValue::const_px(5),

                PixelValue::const_px(10)

            )

            .print_as_css_value(),

            "5px 10px"

        );

        // Same number, different unit -> still two values (the metric is part of Eq).

        assert_eq!(

            LayoutBorderSpacing::new_separate(

                PixelValue::const_px(0),

                PixelValue::percent(0.0)

            )

            .print_as_css_value(),

            "0px 0%"

        );

        assert_eq!(

            LayoutBorderSpacing::default().print_as_css_value(),

            "0px",

            "the default must not print as a two-value form"

        );

    }

    #[test]

    fn border_spacing_saturated_value_roundtrips_stably() {

        // The saturated bound prints as a lossy f32 (9223372000000000px), but

        // re-parsing it saturates right back to the same stored bound, so the

        // round-trip is still a fixed point.

        let saturated = parse_border_spacing("infpx").unwrap();

        let printed = saturated.print_as_css_value();

        assert_eq!(parse_border_spacing(&printed).unwrap(), saturated);

        let low = parse_border_spacing("-infpx").unwrap();

        assert_eq!(

            parse_border_spacing(&low.print_as_css_value()).unwrap(),

            low

        );

    }

    #[test]

    fn border_spacing_parse_print_is_idempotent_after_quantization() {

        // Inputs whose precision the fixed-point representation cannot hold must

        // reach a fixed point after a single round-trip, not drift on every pass.

        for input in ["0.0005px", "0.9999px", "0.1px", "1e40px", "NaNpx", "-0"] {

            let once = parse_border_spacing(input).unwrap();

            let printed = once.print_as_css_value();

            let twice = parse_border_spacing(&printed).unwrap();

            assert_eq!(once, twice, "not idempotent for {input:?}");

            assert_eq!(printed, twice.print_as_css_value(), "not stable for {input:?}");

        }

    }

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

    // FormatAsRustCode

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

    #[test]

    fn format_as_rust_code_emits_the_variant_paths() {

        assert_eq!(

            LayoutTableLayout::Fixed.format_as_rust_code(0),

            "LayoutTableLayout::Fixed"

        );

        assert_eq!(

            StyleBorderCollapse::Collapse.format_as_rust_code(0),

            "StyleBorderCollapse::Collapse"

        );

        assert_eq!(

            StyleCaptionSide::Bottom.format_as_rust_code(0),

            "StyleCaptionSide::Bottom"

        );

        assert_eq!(StyleEmptyCells::Hide.format_as_rust_code(0), "StyleEmptyCells::Hide");

        // The indent argument is ignored -- it must not change the output.

        assert_eq!(

            LayoutTableLayout::Auto.format_as_rust_code(0),

            LayoutTableLayout::Auto.format_as_rust_code(usize::MAX)

        );

    }

    #[test]

    fn format_as_rust_code_for_border_spacing_is_total() {

        assert_eq!(

            LayoutBorderSpacing::new(PixelValue::const_px(5)).format_as_rust_code(0),

            "LayoutBorderSpacing { horizontal: \

             PixelValue::const_from_metric_fractional(SizeMetric::Px, 5, 0), vertical: \

             PixelValue::const_from_metric_fractional(SizeMetric::Px, 5, 0) }"

        );

        // Extreme / degenerate values must still format without panicking.

        for v in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::MIN, -2.5] {

            let code = LayoutBorderSpacing::new(PixelValue::px(v)).format_as_rust_code(0);

            assert!(code.starts_with("LayoutBorderSpacing {"), "{v}: {code}");

            assert!(code.ends_with('}'), "{v}: {code}");

        }

    }

}