//! CSS properties for managing content overflow.

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

use crate::corety::{AzString, OptionF32};

use crate::props::formatter::PrintAsCssValue;

// +spec:overflow:647a7b - overflow property (visible/hidden/clip/scroll/auto), overflow-clip-margin, text-overflow defined in CSS Overflow 3

/// Represents an `overflow-x` or `overflow-y` property.

///

/// Determines what to do when content overflows an element's box.

// +spec:overflow:3526f7 - overflow property with scroll/clip/hidden/visible/auto values

// +spec:overflow:36c4f6 - overflow-x/overflow-y properties with clip value

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

#[repr(C)]

pub enum LayoutOverflow {

    /// Always shows a scroll bar, overflows on scroll.

    Scroll,

    /// Shows a scroll bar only when content overflows.

    Auto,

    /// Clips overflowing content. The rest of the content will be invisible.

    Hidden,

    /// Content is not clipped and renders outside the element's box. This is the CSS default.

    // +spec:overflow:236100 - initial value of 'overflow' is 'visible'

    #[default]

    Visible,

    /// Similar to `hidden`, clips the content at the box's edge.

    Clip,

}

impl LayoutOverflow {

    /// Returns whether this overflow value requires a scrollbar to be displayed.

    ///

    /// - `overflow: scroll` always shows the scrollbar.

    /// - `overflow: auto` only shows the scrollbar if the content is currently overflowing.

    /// - `overflow: hidden`, `overflow: visible`, and `overflow: clip` do not show any scrollbars.

    // +spec:overflow:2bf182 - overflow:scroll always shows scrollbar whether or not content is clipped

    // +spec:overflow:84cd40 - scroll value always displays scrollbar for accessing clipped content

    // +spec:overflow:8fcdd8 - auto causes scrolling mechanism for overflowing boxes (table exception is UA-level)

        }

    // +spec:overflow:145749 - overflow:hidden clips content to containing element box

    // +spec:overflow:3dc18e - overflow:hidden clips content with no scrolling UI

    // +spec:overflow:81e306 - clipping region clips all aspects outside it; clipped content does not cause overflow

    // +spec:overflow:fd38ce - overflow properties specify whether a box's content is clipped / scroll container

    /// Returns `true` if this overflow value clips content (everything except `visible`).

        // All overflow values except 'visible' clip their content

            Self::Hidden

                | Self::Clip

                | Self::Auto

                | Self::Scroll

        )

    /// Returns `true` if the overflow type is `scroll`.

    // +spec:overflow:3be57c - overflow:hidden disables user scrolling but programmatic scrolling still works

    /// Does this value establish a SCROLL CONTAINER (css-overflow-3 §3.1)?

    ///

    /// `hidden`, `scroll` and `auto` all do — an `overflow: hidden` box is

    /// programmatically scrollable (scrollIntoView, scroll offsets set from

    /// callbacks) even though its user-facing scrolling UI is disabled.

    /// `visible` and `clip` do not scroll at all.

    /// Does this value allow scrolling DIRECTLY TRIGGERED BY THE USER

    /// (wheel, trackpad, scrollbar drag, keyboard)? `hidden` does not —

    /// only programmatic scrolling reaches it.

    /// Returns `true` if the overflow type is `visible`, which is the only

    /// overflow type that doesn't clip its children.

    /// Returns `true` if the overflow type is `hidden`.

    // +spec:overflow:833078 - visible/clip compute to auto/hidden if other axis is scrollable

    /// Resolves the computed value per CSS Overflow 3 § 3.1:

    /// visible/clip values compute to auto/hidden (respectively)

    /// if the other axis is neither visible nor clip.

            }

        } else {

        }

}

impl PrintAsCssValue for LayoutOverflow {

        })

}

// -- Parser

/// Error returned when parsing an `overflow` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum LayoutOverflowParseError<'a> {

    /// The provided value is not a valid `overflow` keyword.

    InvalidValue(&'a str),

}

impl_debug_as_display!(LayoutOverflowParseError<'a>);

impl_display! { LayoutOverflowParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid overflow value: \"{}\". Expected 'scroll', 'auto', 'hidden', 'visible', or 'clip'.", val

    ),

}}

/// An owned version of `LayoutOverflowParseError`.

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

#[repr(C, u8)]

pub enum LayoutOverflowParseErrorOwned {

    InvalidValue(AzString),

}

impl LayoutOverflowParseError<'_> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl LayoutOverflowParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `LayoutOverflow` from a string slice.

/// # Errors

///

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

    }

// -- StyleScrollbarGutter --

// +spec:box-model:e98b7c - scrollbar gutter: space between inner border edge and outer padding edge

/// Represents the `scrollbar-gutter` CSS property.

///

/// Controls whether space is reserved for the scrollbar, preventing

/// layout shifts when content overflows.

// +spec:overflow:da4bbc - scrollbar-gutter affects gutter presence, not scrollbar visibility

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

#[repr(C)]

pub enum StyleScrollbarGutter {

    /// No scrollbar gutter is reserved.

    #[default]

    Auto,

    /// Space is reserved for the scrollbar on one edge.

    Stable,

    /// Space is reserved for the scrollbar on both edges.

    StableBothEdges,

}

impl PrintAsCssValue for StyleScrollbarGutter {

        })

}

// -- Parser for StyleScrollbarGutter

/// Error returned when parsing a `scrollbar-gutter` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleScrollbarGutterParseError<'a> {

    /// The provided value is not a valid `scrollbar-gutter` keyword.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleScrollbarGutterParseError<'a>);

impl_display! { StyleScrollbarGutterParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid scrollbar-gutter value: \"{}\". Expected 'auto', 'stable', or 'stable both-edges'.", val

    ),

}}

/// An owned version of `StyleScrollbarGutterParseError`.

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

#[repr(C, u8)]

pub enum StyleScrollbarGutterParseErrorOwned {

    InvalidValue(AzString),

}

impl StyleScrollbarGutterParseError<'_> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleScrollbarGutterParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `StyleScrollbarGutter` from a string slice.

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `scrollbar-gutter` value.

    }

// -- StyleTextOverflow --

// +spec:overflow:647a7b - text-overflow property defined in CSS Overflow 3

/// Represents the `text-overflow` CSS property.

///

/// Determines how inline content that is clipped (because the block container

/// has `overflow` other than `visible`) is signaled to the user at the end of

/// the line box.

///

/// CSS Overflow Module Level 3 §5: <https://www.w3.org/TR/css-overflow-3/#text-overflow>

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

#[repr(C)]

pub enum StyleTextOverflow {

    /// Clip the inline content at the edge of its line box. This is the initial value.

    #[default]

    Clip,

    /// Render an ellipsis (`…`, U+2026) to represent clipped inline content.

    Ellipsis,

}

impl PrintAsCssValue for StyleTextOverflow {

        })

}

// -- Parser for StyleTextOverflow

/// Error returned when parsing a `text-overflow` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleTextOverflowParseError<'a> {

    /// The provided value is not a valid `text-overflow` keyword.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleTextOverflowParseError<'a>);

impl_display! { StyleTextOverflowParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid text-overflow value: \"{}\". Expected 'clip' or 'ellipsis'.", val

    ),

}}

/// An owned version of `StyleTextOverflowParseError`.

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

#[repr(C, u8)]

pub enum StyleTextOverflowParseErrorOwned {

    InvalidValue(AzString),

}

impl StyleTextOverflowParseError<'_> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleTextOverflowParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `StyleTextOverflow` from a string slice.

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `text-overflow` value.

    }

// -- VisualBox --

// +spec:overflow:f6955f - box edge origin for overflow-clip-margin

/// Represents the `<visual-box>` value used as the overflow clip edge origin.

///

/// Specifies which box edge to use as the starting point for the clip region.

/// Defaults to `padding-box` per CSS Overflow Module Level 3.

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

#[repr(C)]

pub enum VisualBox {

    /// Clip edge starts at the content box edge.

    ContentBox,

    /// Clip edge starts at the padding box edge (default).

    #[default]

    PaddingBox,

    /// Clip edge starts at the border box edge.

    BorderBox,

}

impl PrintAsCssValue for VisualBox {

        })

}

// -- StyleOverflowClipMargin --

/// Represents the `overflow-clip-margin` CSS property.

///

/// Determines how far outside the element's box the content may paint

/// before being clipped when `overflow: clip` is used.

/// Syntax: `<visual-box> || <length [0,∞]>`

// +spec:overflow:455786 - overflow-clip-margin has no effect on hidden/scroll, only on clip

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

#[repr(C)]

pub struct StyleOverflowClipMargin {

    /// The box edge to use as the clip origin (content-box, padding-box, or border-box).

    pub clip_edge: VisualBox,

    /// The clip margin distance beyond the clip edge.

    pub inner: crate::props::basic::pixel::PixelValue,

}

impl PrintAsCssValue for StyleOverflowClipMargin {

        #[allow(clippy::float_cmp)] // exact zero check: value is default-initialized, not computed

        } else {

        }

}

/// Error returned when parsing an `overflow-clip-margin` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleOverflowClipMarginParseError<'a> {

    /// The provided value is not a valid `overflow-clip-margin` value.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleOverflowClipMarginParseError<'a>);

impl_display! { StyleOverflowClipMarginParseError<'a>, {

    InvalidValue(val) => format!("Invalid overflow-clip-margin value: \"{}\"", val),

}}

/// An owned version of `StyleOverflowClipMarginParseError`.

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

#[repr(C, u8)]

pub enum StyleOverflowClipMarginParseErrorOwned {

    InvalidValue(AzString),

}

impl StyleOverflowClipMarginParseError<'_> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleOverflowClipMarginParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `StyleOverflowClipMargin` from a string slice.

///

/// Syntax: `<visual-box> || <length [0,∞]>`

/// The `<visual-box>` defaults to `padding-box` if omitted.

/// The `<length>` defaults to `0px` if omitted.

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `overflow-clip-margin` value.

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

                }

            }

        }

    }

// -- StyleClipRect --

/// Represents the deprecated CSS `clip` property value `rect(top, right, bottom, left)`.

///

/// Each edge can be a length or `auto`. When `auto`, the edge matches the

/// element's generated border box edge:

/// - `auto` for top/left = 0

/// - `auto` for bottom = used height + vertical padding + vertical border

/// - `auto` for right = used width + horizontal padding + horizontal border

///

/// Negative lengths are permitted.

// +spec:overflow:297dc3 - clip rect() auto values resolve to border box edges

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

#[repr(C)]

pub struct StyleClipRect {

    /// Top edge offset in pixels. `None` means `auto` (= 0).

    pub top: OptionF32,

    /// Right edge offset in pixels. `None` means `auto` (= used width + horiz padding + horiz border).

    pub right: OptionF32,

    /// Bottom edge offset in pixels. `None` means `auto` (= used height + vert padding + vert border).

    pub bottom: OptionF32,

    /// Left edge offset in pixels. `None` means `auto` (= 0).

    pub left: OptionF32,

}

impl StyleClipRect {

    /// Resolves `auto` values to border box edges given the element's

    /// used width/height and padding/border sizes.

    ///

    /// Returns `(top, right, bottom, left)` in pixels.

}

impl PrintAsCssValue for StyleClipRect {

        )

}

// -- Parser for StyleClipRect

/// Error returned when parsing a CSS `clip` property value fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleClipRectParseError<'a> {

    /// The provided value is not a valid `clip` value.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleClipRectParseError<'a>);

impl_display! { StyleClipRectParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid clip value: \"{}\". Expected 'auto' or 'rect(<top>, <right>, <bottom>, <left>)'.", val

    ),

}}

/// An owned version of `StyleClipRectParseError`.

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

#[repr(C, u8)]

pub enum StyleClipRectParseErrorOwned {

    InvalidValue(AzString),

}

impl StyleClipRectParseError<'_> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleClipRectParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

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

#[cfg(feature = "parser")]

/// Parses a `StyleClipRect` from a string slice.

///

/// Accepts:

/// - `auto` — equivalent to `rect(auto, auto, auto, auto)`.

/// - `rect(<top>, <right>, <bottom>, <left>)` — comma-separated form.

/// - `rect(<top> <right> <bottom> <left>)` — legacy space-separated form.

///

/// Each edge is either `auto` or a `<length>`. Negative lengths are permitted.

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `clip-rect` value.

    } else {

    };

    Ok(StyleClipRect {

    })

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

mod tests {

    use super::*;

    #[test]

            LayoutOverflow::Visible

        );

            LayoutOverflow::Hidden

        );

            LayoutOverflow::Scroll

        );

    #[test]

            StyleTextOverflow::Clip

        );

            StyleTextOverflow::Ellipsis

        );

        // whitespace is tolerated

            StyleTextOverflow::Ellipsis

        );

        // initial value is `clip`

    #[test]

        // error message names the property and quotes the value

            StyleTextOverflowParseError::InvalidValue("fade")

        );

        // owned <-> shared round-trips

    #[test]

        }

    #[test]

            LayoutOverflow::Scroll

        );

    #[test]

    #[test]

    #[test]

    #[test]

    #[test]

    #[test]

    #[test]

        // Legacy CSS 2.1 syntax used spaces instead of commas.

    #[test]

        // Wrong number of edges.

        // Missing closing paren.

        // Garbage edge.

}

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

mod autotest_generated {

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

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

    use super::*;

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

    // Variant tables. Each is kept honest by an exhaustive `match` below:

    // adding a variant to the enum stops the index fn from compiling.

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

    const ALL_OVERFLOW: [LayoutOverflow; 5] = [

        LayoutOverflow::Scroll,

        LayoutOverflow::Auto,

        LayoutOverflow::Hidden,

        LayoutOverflow::Visible,

        LayoutOverflow::Clip,

    ];

    const fn overflow_variant_index(o: LayoutOverflow) -> usize {

        match o {

            LayoutOverflow::Scroll => 0,

            LayoutOverflow::Auto => 1,

            LayoutOverflow::Hidden => 2,

            LayoutOverflow::Visible => 3,

            LayoutOverflow::Clip => 4,

        }

    }

    const ALL_GUTTER: [StyleScrollbarGutter; 3] = [

        StyleScrollbarGutter::Auto,

        StyleScrollbarGutter::Stable,

        StyleScrollbarGutter::StableBothEdges,

    ];

    const fn gutter_variant_index(g: StyleScrollbarGutter) -> usize {

        match g {

            StyleScrollbarGutter::Auto => 0,

            StyleScrollbarGutter::Stable => 1,

            StyleScrollbarGutter::StableBothEdges => 2,

        }

    }

    const ALL_VISUAL_BOX: [VisualBox; 3] = [

        VisualBox::ContentBox,

        VisualBox::PaddingBox,

        VisualBox::BorderBox,

    ];

    const fn visual_box_variant_index(v: VisualBox) -> usize {

        match v {

            VisualBox::ContentBox => 0,

            VisualBox::PaddingBox => 1,

            VisualBox::BorderBox => 2,

        }

    }

    /// A value is "scrollable" (per CSS Overflow 3 § 3.1) when it is neither

    /// `visible` nor `clip` — i.e. it establishes a scroll container.

    const fn is_scrollable(o: LayoutOverflow) -> bool {

        !matches!(o, LayoutOverflow::Visible | LayoutOverflow::Clip)

    }

    #[test]

    fn variant_tables_cover_every_variant_exactly_once() {

        for (i, o) in ALL_OVERFLOW.iter().enumerate() {

            assert_eq!(overflow_variant_index(*o), i);

        }

        for (i, g) in ALL_GUTTER.iter().enumerate() {

            assert_eq!(gutter_variant_index(*g), i);

        }

        for (i, v) in ALL_VISUAL_BOX.iter().enumerate() {

            assert_eq!(visual_box_variant_index(*v), i);

        }

    }

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

    // LayoutOverflow — predicates & invariants

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

    #[test]

    fn needs_scrollbar_truth_table_is_monotone_in_currently_overflowing() {

        for o in ALL_OVERFLOW {

            let idle = o.needs_scrollbar(false);

            let overflowing = o.needs_scrollbar(true);

            // A scrollbar that is shown while *not* overflowing must also be

            // shown while overflowing — the flag can only ever add scrollbars.

            assert!(

                !idle || overflowing,

                "{o:?} shows a scrollbar when idle but hides it when overflowing"

            );

            // Only `scroll` shows a scrollbar unconditionally; only `auto`

            // reacts to the flag; nothing else ever shows one.

            let (expect_idle, expect_overflowing) = match o {

                LayoutOverflow::Scroll => (true, true),

                LayoutOverflow::Auto => (false, true),

                LayoutOverflow::Hidden | LayoutOverflow::Visible | LayoutOverflow::Clip => {

                    (false, false)

                }

            };

            assert_eq!(idle, expect_idle, "needs_scrollbar(false) wrong for {o:?}");

            assert_eq!(

                overflowing, expect_overflowing,

                "needs_scrollbar(true) wrong for {o:?}"

            );

            // Anything that can show a scrollbar must also clip.

            assert!(!overflowing || o.is_clipped());

        }

    }

    #[test]

    fn is_clipped_is_exactly_the_negation_of_is_overflow_visible() {

        for o in ALL_OVERFLOW {

            assert_eq!(

                o.is_clipped(),

                !o.is_overflow_visible(),

                "is_clipped/is_overflow_visible disagree for {o:?}"

            );

            // Deterministic: repeated calls on the same value never differ.

            assert_eq!(o.is_clipped(), o.is_clipped());

        }

        assert!(!LayoutOverflow::Visible.is_clipped());

        assert!(LayoutOverflow::Hidden.is_clipped());

    }

    #[test]

    fn is_scroll_and_is_overflow_hidden_match_exactly_one_variant_each() {

        let scrolls: Vec<LayoutOverflow> =

            ALL_OVERFLOW.into_iter().filter(LayoutOverflow::is_scroll).collect();

        assert_eq!(scrolls, vec![LayoutOverflow::Scroll]);

        let hiddens: Vec<LayoutOverflow> = ALL_OVERFLOW

            .into_iter()

            .filter(LayoutOverflow::is_overflow_hidden)

            .collect();

        assert_eq!(hiddens, vec![LayoutOverflow::Hidden]);

        // `auto` is not `scroll`, even though both can produce a scrollbar.

        assert!(!LayoutOverflow::Auto.is_scroll());

        assert!(LayoutOverflow::Auto.needs_scrollbar(true));

    }

    #[test]

    fn default_overflow_is_visible_and_neither_clips_nor_scrolls() {

        let d = LayoutOverflow::default();

        assert_eq!(d, LayoutOverflow::Visible);

        assert!(d.is_overflow_visible());

        assert!(!d.is_clipped());

        assert!(!d.is_scroll());

        assert!(!d.is_overflow_hidden());

        assert!(!d.needs_scrollbar(false));

        assert!(!d.needs_scrollbar(true));

    }

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

    // LayoutOverflow::resolve_computed — CSS Overflow 3 § 3.1

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

    #[test]

    fn resolve_computed_is_identity_when_the_other_axis_is_not_scrollable() {

        for other in [LayoutOverflow::Visible, LayoutOverflow::Clip] {

            for o in ALL_OVERFLOW {

                assert_eq!(

                    o.resolve_computed(other),

                    o,

                    "{o:?} must be untouched when the other axis is {other:?}"

                );

            }

        }

    }

    #[test]

    fn resolve_computed_promotes_visible_to_auto_and_clip_to_hidden() {

        for other in [

            LayoutOverflow::Scroll,

            LayoutOverflow::Auto,

            LayoutOverflow::Hidden,

        ] {

            assert_eq!(

                LayoutOverflow::Visible.resolve_computed(other),

                LayoutOverflow::Auto

            );

            assert_eq!(

                LayoutOverflow::Clip.resolve_computed(other),

                LayoutOverflow::Hidden

            );

            // Already-scrollable values are left alone.

            for o in [

                LayoutOverflow::Scroll,

                LayoutOverflow::Auto,

                LayoutOverflow::Hidden,

            ] {

                assert_eq!(o.resolve_computed(other), o);

            }

        }

    }

    #[test]

    fn resolve_computed_is_idempotent_and_never_removes_clipping() {

        for o in ALL_OVERFLOW {

            for other in ALL_OVERFLOW {

                let once = o.resolve_computed(other);

                assert_eq!(

                    once.resolve_computed(other),

                    once,

                    "resolve_computed not idempotent for ({o:?}, {other:?})"

                );

                // Resolution only ever adds clipping, never takes it away.

                assert!(

                    !o.is_clipped() || once.is_clipped(),

                    "({o:?}, {other:?}) lost clipping"

                );

                // ...and never turns a scroll container back into a non-scroller.

                assert!(!is_scrollable(o) || is_scrollable(once));

            }

        }

    }

    #[test]

    fn resolve_computed_leaves_both_axes_consistently_scrollable() {

        // The whole point of the rule: after resolving *both* axes against each

        // other you can never end up with one scrollable axis and one that is

        // still visible/clip (which would be unrenderable).

        for x in ALL_OVERFLOW {

            for y in ALL_OVERFLOW {

                let rx = x.resolve_computed(y);

                let ry = y.resolve_computed(x);

                assert_eq!(

                    is_scrollable(rx),

                    is_scrollable(ry),

                    "({x:?}, {y:?}) resolved to the mismatched pair ({rx:?}, {ry:?})"

                );

            }

        }

        // Spot-check the documented pairs.

        assert_eq!(

            LayoutOverflow::Visible.resolve_computed(LayoutOverflow::Scroll),

            LayoutOverflow::Auto

        );

        assert_eq!(

            LayoutOverflow::Scroll.resolve_computed(LayoutOverflow::Visible),

            LayoutOverflow::Scroll

        );

        // visible + clip is a legal pair and must survive untouched.

        assert_eq!(

            LayoutOverflow::Visible.resolve_computed(LayoutOverflow::Clip),

            LayoutOverflow::Visible

        );

        assert_eq!(

            LayoutOverflow::Clip.resolve_computed(LayoutOverflow::Visible),

            LayoutOverflow::Clip

        );

    }

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

    // parse_layout_overflow

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

    #[test]

    fn layout_overflow_round_trips_through_print_as_css_value() {

        for o in ALL_OVERFLOW {

            let printed = o.print_as_css_value();

            assert_eq!(

                parse_layout_overflow(&printed).unwrap(),

                o,

                "{o:?} printed as {printed:?} did not round-trip"

            );

            // The printed form is a bare keyword: no whitespace, all lowercase.

            assert!(!printed.is_empty());

            assert!(!printed.contains(char::is_whitespace));

            assert_eq!(printed, printed.to_lowercase());

        }

    }

    #[test]

    fn parse_layout_overflow_treats_overlay_as_a_one_way_alias_of_auto() {

        // "overlay" is a legacy alias that parses to Auto but is never printed,

        // so the round-trip is stable only after the first normalisation.

        assert_eq!(parse_layout_overflow("overlay").unwrap(), LayoutOverflow::Auto);

        let normalised = parse_layout_overflow("overlay").unwrap().print_as_css_value();

        assert_eq!(normalised, "auto");

        assert_eq!(

            parse_layout_overflow(&normalised).unwrap(),

            LayoutOverflow::Auto

        );

        for o in ALL_OVERFLOW {

            assert_ne!(o.print_as_css_value(), "overlay");

        }

    }

    #[test]

    fn parse_layout_overflow_rejects_empty_and_whitespace_only_input() {

        for input in ["", " ", "   ", "\t", "\n", "\r\n", "\t \n \r", "\u{00A0}"] {

            assert!(

                parse_layout_overflow(input).is_err(),

                "{input:?} must not parse"

            );

        }

    }

    #[test]

    fn parse_layout_overflow_error_carries_the_untrimmed_input() {

        // The parser trims for matching but reports the *original* slice.

        let err = parse_layout_overflow("  bogus  ").unwrap_err();

        assert_eq!(err, LayoutOverflowParseError::InvalidValue("  bogus  "));

        let msg = format!("{err}");

        assert!(msg.contains("bogus"), "{msg}");

        assert!(msg.contains("scroll"), "error should list the valid keywords: {msg}");

    }

    #[test]

    fn parse_layout_overflow_is_ascii_case_sensitive() {

        // NOTE: CSS keywords are ASCII case-insensitive, but this parser only

        // accepts the lowercase spelling (property *names* are lowercased

        // upstream, values are not). Characterised here so a future fix has to

        // update the test deliberately.

        for input in ["SCROLL", "Scroll", "sCrOlL", "AUTO", "Hidden", "VISIBLE", "Clip"] {

            assert!(

                parse_layout_overflow(input).is_err(),

                "{input:?} unexpectedly parsed"

            );

        }

        assert_eq!(parse_layout_overflow("scroll").unwrap(), LayoutOverflow::Scroll);

    }

    #[test]

    fn parse_layout_overflow_trims_unicode_whitespace_but_not_zero_width_chars() {

        // `str::trim` uses the Unicode White_Space property, which is wider than

        // CSS whitespace: NBSP and the ideographic space are stripped too.

        assert_eq!(

            parse_layout_overflow("\u{00A0}scroll\u{00A0}").unwrap(),

            LayoutOverflow::Scroll

        );

        assert_eq!(

            parse_layout_overflow("\u{3000}auto").unwrap(),

            LayoutOverflow::Auto

        );

        // ...but a zero-width space is not whitespace, so it stays and rejects.

        assert!(parse_layout_overflow("\u{200B}scroll").is_err());

        assert!(parse_layout_overflow("scroll\u{FEFF}").is_err());

    }

    #[test]

    fn parse_layout_overflow_rejects_garbage_unicode_and_boundary_numbers() {

        for input in [

            "none",

            "hidden-x",

            "auto scroll",

            "scroll;",

            "scroll garbage",

            "visible !important",

            "\0",

            "scroll\0",

            "!@#$%^&*()",

            "\u{1F600}",

            "scroll\u{1F600}",

            "e\u{0301}",

            "ｓｃｒｏｌｌ",

            "скролл",

            "0",

            "-0",

            "0.0",

            "NaN",

            "nan",

            "inf",

            "-inf",

            "infinity",

            "9223372036854775807",

            "-9223372036854775808",

            "1e400",

            "1e-400",

        ] {

            assert!(

                parse_layout_overflow(input).is_err(),

                "{input:?} unexpectedly parsed"

            );

        }

    }

    #[test]

    fn parse_layout_overflow_survives_extremely_long_and_deeply_nested_input() {

        let long = "scroll".repeat(200_000);

        assert!(parse_layout_overflow(&long).is_err());

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

        assert!(parse_layout_overflow(&junk).is_err());

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

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

        // A valid keyword buried in megabytes of padding is still just padding.

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

        assert_eq!(parse_layout_overflow(&padded).unwrap(), LayoutOverflow::Scroll);

    }

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

    // parse_style_scrollbar_gutter

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

    #[test]

    fn scrollbar_gutter_round_trips_through_print_as_css_value() {

        for g in ALL_GUTTER {

            let printed = g.print_as_css_value();

            assert_eq!(

                parse_style_scrollbar_gutter(&printed).unwrap(),

                g,

                "{g:?} printed as {printed:?} did not round-trip"

            );

        }

        assert_eq!(

            StyleScrollbarGutter::StableBothEdges.print_as_css_value(),

            "stable both-edges"

        );

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

    }

    #[test]

    fn parse_style_scrollbar_gutter_matches_the_keyword_string_verbatim() {

        // The parser compares the whole trimmed string, so it accepts exactly

        // one ASCII space between `stable` and `both-edges`. Per the grammar

        // (`auto | stable && both-edges?`) the reversed order and collapsed

        // runs of whitespace should also be legal — characterising the gap.

        assert_eq!(

            parse_style_scrollbar_gutter("stable both-edges").unwrap(),

            StyleScrollbarGutter::StableBothEdges

        );

        for rejected in [

            "stable  both-edges", // two spaces

            "stable\tboth-edges",

            "stable\nboth-edges",

            "both-edges stable", // `&&` allows either order

            "both-edges",

            "STABLE",

            "Stable Both-Edges",

            "stable both-edges stable",

        ] {

            assert!(

                parse_style_scrollbar_gutter(rejected).is_err(),

                "{rejected:?} unexpectedly parsed"

            );

        }

        // Outer whitespace *is* trimmed.

        assert_eq!(

            parse_style_scrollbar_gutter("  stable both-edges \n").unwrap(),

            StyleScrollbarGutter::StableBothEdges

        );

    }

    #[test]

    fn parse_style_scrollbar_gutter_rejects_empty_garbage_unicode_and_numbers() {

        for input in [

            "", " ", "\t\n", "none", "auto stable", "auto;", "stable;", "0", "-0", "NaN", "inf",

            "9223372036854775807", "\u{1F600}", "ｓｔａｂｌｅ", "stable\0",

        ] {

            assert!(

                parse_style_scrollbar_gutter(input).is_err(),

                "{input:?} unexpectedly parsed"

            );

        }

        let err = parse_style_scrollbar_gutter("  nope  ").unwrap_err();

        assert_eq!(

            err,

            StyleScrollbarGutterParseError::InvalidValue("  nope  ")

        );

        assert!(format!("{err}").contains("scrollbar-gutter"));

    }

    #[test]

    fn parse_style_scrollbar_gutter_survives_long_and_nested_input() {

        let long = "stable ".repeat(200_000);

        assert!(parse_style_scrollbar_gutter(&long).is_err());

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

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

    }

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

    // parse_style_overflow_clip_margin

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

    #[test]

    fn parse_style_overflow_clip_margin_accepts_either_component_in_either_order() {

        // <visual-box> only — length defaults to 0.

        let only_box = parse_style_overflow_clip_margin("content-box").unwrap();

        assert_eq!(only_box.clip_edge, VisualBox::ContentBox);