//! CSS properties for generated content (`content`, `counter-reset`,

//! `counter-increment`, `string-set`).

//!

//! Defines [`Content`], [`CounterReset`], [`CounterIncrement`], and

//! [`StringSet`], which are registered as [`CssProperty`] variants.

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

use crate::{corety::AzString, props::formatter::PrintAsCssValue};

/// CSS `content` property value, stored as a raw string.

///

/// Intentionally simplified: stores the unparsed CSS value rather than

/// a structured `ContentPart` enum. Complex values like `counter(section) ". "`

/// are preserved verbatim but not individually evaluated.

///

/// **Note:** Currently parsed and stored but not yet consumed by the layout

/// engine (e.g., for `::before`/`::after` pseudo-element generated content).

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

#[repr(C)]

pub struct Content {

    pub inner: AzString,

}

impl Default for Content {

}

impl PrintAsCssValue for Content {

}

/// CSS `counter-reset` property: resets a named counter to a given value.

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

#[repr(C)]

pub struct CounterReset {

    pub counter_name: AzString,

    pub value: i32,

}

impl CounterReset {

}

impl Default for CounterReset {

}

impl PrintAsCssValue for CounterReset {

        } else {

        }

}

/// CSS `counter-increment` property: increments a named counter by a given value.

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

#[repr(C)]

pub struct CounterIncrement {

    pub counter_name: AzString,

    pub value: i32,

}

impl CounterIncrement {

}

impl Default for CounterIncrement {

}

impl PrintAsCssValue for CounterIncrement {

        } else {

        }

}

/// CSS `string-set` property value, stored as a raw string.

///

/// **Note:** Currently parsed and stored but not yet consumed by the layout engine.

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

#[repr(C)]

pub struct StringSet {

    pub inner: AzString,

}

impl Default for StringSet {

}

impl PrintAsCssValue for StringSet {

}

// Formatting to Rust code

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

}

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

            self.value

        )

}

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

            self.value

        )

}

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

}

// --- PARSERS ---

#[cfg(feature = "parser")]

pub mod parser {

    #[allow(clippy::wildcard_imports)] // parser submodule reuses the parent module's value types

    use super::*;

    // Simplified parsers that just take the raw string value.

    /// # Errors

    ///

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

        } else {

        };

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `counter-reset` value.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `counter-increment` value.

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `string-set` value.

}

#[cfg(feature = "parser")]

pub use parser::*;

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

mod tests {

    use super::*;

    #[test]

        // Test counter-reset parsing

        // Test counter-increment parsing

            "chapter-title content()"

        );

}

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

mod autotest_generated {

    use std::{

        collections::hash_map::DefaultHasher,

        hash::{Hash, Hasher},

    };

    use super::*;

    use crate::codegen::format::FormatAsRustCode;

    fn hash_of<T: Hash>(t: &T) -> u64 {

        let mut h = DefaultHasher::new();

        t.hash(&mut h);

        h.finish()

    }

    /// Nasty inputs that must never panic in any parser in this module.

    fn hostile_corpus() -> Vec<String> {

        alloc::vec![

            String::new(),

            " ".to_string(),

            "\t\n\r\u{b}\u{c}".to_string(),

            "\u{a0}".to_string(),      // NBSP: Unicode White_Space

            "\u{200b}".to_string(),    // ZWSP: NOT White_Space

            "\0".to_string(),          // embedded NUL

            "\0page\0 1\0".to_string(),

            ";".to_string(),

            "}{".to_string(),

            "counter(section) \". \"".to_string(),

            "-".to_string(),

            "--".to_string(),

            "+".to_string(),

            "e".to_string(),

            "NaN".to_string(),

            "inf".to_string(),

            "-inf".to_string(),

            "\u{1F600}".to_string(),

            "a\u{0301}\u{0301}\u{0301}".to_string(), // stacked combining marks

            "\u{202e}reversed".to_string(),          // RTL override

            "page 1 page 2 page 3".to_string(),

            "page \u{fffd}".to_string(),

            "\"unterminated".to_string(),

            "url(".to_string(),

        ]

    }

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

    // Constructors: CounterReset::{new,none,list_item}

    //               CounterIncrement::{new,none,list_item}

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

    #[test]

    fn counter_constructors_preserve_fields_at_i32_extremes() {

        for value in [i32::MIN, i32::MIN + 1, -1, 0, 1, i32::MAX - 1, i32::MAX] {

            let r = CounterReset::new(AzString::from_const_str("c"), value);

            assert_eq!(r.counter_name.as_str(), "c");

            assert_eq!(r.value, value);

            let i = CounterIncrement::new(AzString::from_const_str("c"), value);

            assert_eq!(i.counter_name.as_str(), "c");

            assert_eq!(i.value, value);

        }

    }

    #[test]

    fn counter_constructors_accept_degenerate_names_verbatim() {

        // Empty, whitespace-laden, unicode and very long names are stored as-is:

        // the constructors perform no validation whatsoever.

        let huge: String = "x".repeat(100_000);

        let names = ["", " ", "a b", "\u{1F600}\u{1F600}", "none", huge.as_str()];

        for name in names {

            let r = CounterReset::new(name.into(), i32::MIN);

            assert_eq!(r.counter_name.as_str(), name);

            assert_eq!(r.counter_name.as_str().len(), name.len());

            assert_eq!(r.value, i32::MIN);

            let i = CounterIncrement::new(name.into(), i32::MAX);

            assert_eq!(i.counter_name.as_str(), name);

            assert_eq!(i.counter_name.as_str().len(), name.len());

            assert_eq!(i.value, i32::MAX);

        }

    }

    #[test]

    fn counter_none_and_list_item_constants() {

        assert_eq!(CounterReset::none().counter_name.as_str(), "none");

        assert_eq!(CounterReset::none().value, 0);

        assert_eq!(CounterReset::default(), CounterReset::none());

        assert_eq!(CounterIncrement::none().counter_name.as_str(), "none");

        assert_eq!(CounterIncrement::none().value, 0);

        assert_eq!(CounterIncrement::default(), CounterIncrement::none());

        // Per CSS, `counter-reset: list-item` starts at 0 while

        // `counter-increment: list-item` steps by 1 -- the asymmetry is intended.

        assert_eq!(CounterReset::list_item().counter_name.as_str(), "list-item");

        assert_eq!(CounterReset::list_item().value, 0);

        assert_eq!(

            CounterIncrement::list_item().counter_name.as_str(),

            "list-item"

        );

        assert_eq!(CounterIncrement::list_item().value, 1);

    }

    #[test]

    fn content_and_string_set_defaults() {

        assert_eq!(Content::default().inner.as_str(), "normal");

        assert_eq!(StringSet::default().inner.as_str(), "none");

    }

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

    // parse_content / parse_string_set  (raw passthrough parsers)

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

    #[test]

    fn content_and_string_set_are_pure_trim_and_never_error() {

        // NOTE: both parsers are infallible despite their `# Errors` docs --

        // they accept empty input and arbitrary garbage. `str::trim` is the

        // exact oracle, which also means Unicode whitespace (NBSP) is stripped

        // while ZWSP is not.

        for input in hostile_corpus() {

            let c = parse_content(&input).expect("parse_content never errors");

            assert_eq!(c.inner.as_str(), input.trim());

            let s = parse_string_set(&input).expect("parse_string_set never errors");

            assert_eq!(s.inner.as_str(), input.trim());

        }

        assert_eq!(parse_content("").unwrap().inner.as_str(), "");

        assert_eq!(parse_content("   \t\n  ").unwrap().inner.as_str(), "");

        assert_eq!(parse_string_set("").unwrap().inner.as_str(), "");

        // NBSP is Unicode White_Space, so it is trimmed away entirely:

        assert_eq!(parse_content("\u{a0}x\u{a0}").unwrap().inner.as_str(), "x");

        // ZWSP is not, so it survives as content:

        assert_eq!(

            parse_content(" \u{200b} ").unwrap().inner.as_str(),

            "\u{200b}"

        );

    }

    #[test]

    fn content_positive_control_and_inner_junk_is_kept() {

        assert_eq!(parse_content("'Hi'").unwrap().inner.as_str(), "'Hi'");

        assert_eq!(parse_content("  'Hi'  ").unwrap().inner.as_str(), "'Hi'");

        // Trailing junk is *not* rejected, only outer whitespace is stripped:

        assert_eq!(

            parse_content("'Hi';garbage").unwrap().inner.as_str(),

            "'Hi';garbage"

        );

        assert_eq!(

            parse_string_set("chapter content()").unwrap().inner.as_str(),

            "chapter content()"

        );

    }

    #[test]

    fn content_extremely_long_input_does_not_hang() {

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

        let padded = alloc::format!("   {huge}\n");

        let c = parse_content(&padded).unwrap();

        assert_eq!(c.inner.as_str().len(), 1_000_000);

        assert!(c.inner.as_str().starts_with("aa"));

        let s = parse_string_set(&padded).unwrap();

        assert_eq!(s.inner.as_str().len(), 1_000_000);

    }

    #[test]

    fn content_deeply_nested_input_does_not_stack_overflow() {

        // The parser is non-recursive, so 10k nested brackets are just bytes.

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

        let c = parse_content(&nested).unwrap();

        assert_eq!(c.inner.as_str().len(), 20_000);

        let deep = alloc::format!("{}x{}", "counter(".repeat(5_000), ")".repeat(5_000));

        assert!(parse_content(&deep).is_ok());

        assert!(parse_string_set(&deep).is_ok());

    }

    #[test]

    fn content_preserves_multibyte_unicode_byte_for_byte() {

        let input = "  \u{1F600}a\u{0301}\u{4e2d}\u{6587}  ";

        let c = parse_content(input).unwrap();

        assert_eq!(c.inner.as_str(), input.trim());

        assert_eq!(c.inner.as_str().len(), input.trim().len());

        // 5 scalar values, not 4 glyphs: U+0301 COMBINING ACUTE ACCENT is its own

        // `char` (it renders as one grapheme with the preceding 'a', but `chars()`

        // counts scalars).

        assert_eq!(c.inner.as_str().chars().count(), 5);

    }

    #[test]

    fn content_boundary_number_strings_are_accepted_as_plain_text() {

        // `content` has no numeric grammar here: numbers survive verbatim.

        for n in [

            "0",

            "-0",

            "9223372036854775807",

            "-9223372036854775808",

            "1e309",

            "NaN",

            "inf",

        ] {

            assert_eq!(parse_content(n).unwrap().inner.as_str(), n);

            assert_eq!(parse_string_set(n).unwrap().inner.as_str(), n);

        }

    }

    #[test]

    fn content_print_parse_roundtrips_for_parsed_values() {

        for input in hostile_corpus() {

            let c = parse_content(&input).unwrap();

            let reparsed = parse_content(&c.print_as_css_value()).unwrap();

            assert_eq!(reparsed, c, "content round-trip failed for {input:?}");

            let s = parse_string_set(&input).unwrap();

            let re_s = parse_string_set(&s.print_as_css_value()).unwrap();

            assert_eq!(re_s, s, "string-set round-trip failed for {input:?}");

        }

        let d = Content::default();

        assert_eq!(parse_content(&d.print_as_css_value()).unwrap(), d);

        let d = StringSet::default();

        assert_eq!(parse_string_set(&d.print_as_css_value()).unwrap(), d);

    }

    #[test]

    fn content_roundtrip_is_lossy_for_untrimmed_handbuilt_values() {

        // print -> parse is only idempotent for already-trimmed values; a value

        // built directly (not via the parser) loses its padding on re-parse.

        let padded = Content {

            inner: "  x  ".into(),

        };

        assert_eq!(padded.print_as_css_value(), "  x  ");

        assert_ne!(parse_content(&padded.print_as_css_value()).unwrap(), padded);

        assert_eq!(

            parse_content(&padded.print_as_css_value())

                .unwrap()

                .inner

                .as_str(),

            "x"

        );

    }

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

    // parse_counter_reset / parse_counter_increment

    // (these fully exercise the private `parse_counter_name_value`:

    //  default_value = 0 for reset, 1 for increment)

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

    #[test]

    fn counter_empty_and_whitespace_only_input_is_rejected() {

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

            assert!(

                parse_counter_reset(input).is_err(),

                "counter-reset accepted whitespace-only {input:?}"

            );

            assert!(

                parse_counter_increment(input).is_err(),

                "counter-increment accepted whitespace-only {input:?}"

            );

        }

    }

    #[test]

    fn counter_missing_value_uses_per_property_default() {

        let r = parse_counter_reset("section").unwrap();

        assert_eq!(r.counter_name.as_str(), "section");

        assert_eq!(r.value, 0);

        let i = parse_counter_increment("section").unwrap();

        assert_eq!(i.counter_name.as_str(), "section");

        assert_eq!(i.value, 1);

    }

    #[test]

    fn counter_none_keyword_is_case_sensitive() {

        // CSS keywords are ASCII case-insensitive, but only lowercase `none`

        // hits the keyword branch. `NONE` is treated as a *counter name*.

        let r = parse_counter_reset("NONE").unwrap();

        assert_eq!(r.counter_name.as_str(), "NONE");

        assert_eq!(r.value, 0);

        let i = parse_counter_increment("None").unwrap();

        assert_eq!(i.counter_name.as_str(), "None");

        assert_eq!(i.value, 1, "uppercase `None` took the counter-name branch");

        // The lowercase keyword branch ignores the property default entirely.

        assert_eq!(parse_counter_increment("none").unwrap().value, 0);

        assert_eq!(parse_counter_increment("  none  ").unwrap().value, 0);

    }

    #[test]

    fn counter_none_with_value_keeps_value_but_prints_as_bare_none() {

        // "none 5" misses the keyword fast-path (it is not *exactly* "none"),

        // so it parses as a counter literally named "none" with value 5 --

        // but PrintAsCssValue then drops the 5, so print->parse is lossy.

        let r = parse_counter_reset("none 5").unwrap();

        assert_eq!(r.counter_name.as_str(), "none");

        assert_eq!(r.value, 5);

        assert_eq!(r.print_as_css_value(), "none");

        let reparsed = parse_counter_reset(&r.print_as_css_value()).unwrap();

        assert_eq!(reparsed.value, 0);

        assert_ne!(reparsed, r, "value 5 silently vanished across a round-trip");

    }

    #[test]

    fn counter_value_at_i32_boundaries_parses_exactly() {

        assert_eq!(parse_counter_reset("c 2147483647").unwrap().value, i32::MAX);

        assert_eq!(parse_counter_reset("c -2147483648").unwrap().value, i32::MIN);

        assert_eq!(parse_counter_reset("c 0").unwrap().value, 0);

        assert_eq!(parse_counter_reset("c -0").unwrap().value, 0);

        assert_eq!(parse_counter_reset("c +7").unwrap().value, 7);

        assert_eq!(parse_counter_reset("c 007").unwrap().value, 7);

        assert_eq!(

            parse_counter_increment("c -2147483648").unwrap().value,

            i32::MIN

        );

    }

    #[test]

    fn counter_value_overflowing_i32_is_rejected_not_wrapped() {

        for over in [

            "c 2147483648",           // i32::MAX + 1

            "c -2147483649",          // i32::MIN - 1

            "c 9223372036854775807",  // i64::MAX

            "c -9223372036854775808", // i64::MIN

            "c 340282366920938463463374607431768211456",

        ] {

            assert!(

                parse_counter_reset(over).is_err(),

                "overflowing value silently accepted: {over:?}"

            );

            assert!(parse_counter_increment(over).is_err());

        }

    }

    #[test]

    fn counter_non_integer_values_are_rejected() {

        for bad in [

            "c 1.0", "c 1.5", "c 1e3", "c NaN", "c nan", "c inf", "c -inf", "c 0x10", "c 1_000",

            "c 1,", "c one", "c -", "c +", "c ٣", // Arabic-Indic digit three

            "c １",  // fullwidth digit one

            "c 1\u{200b}",

        ] {

            assert!(

                parse_counter_reset(bad).is_err(),

                "counter-reset accepted non-integer {bad:?}"

            );

            assert!(

                parse_counter_increment(bad).is_err(),

                "counter-increment accepted non-integer {bad:?}"

            );

        }

    }

    #[test]

    fn counter_extra_tokens_after_the_first_pair_are_silently_dropped() {

        // CSS allows a *list* of counters; this parser keeps only the first

        // name/value pair and discards the rest without erroring.

        let r = parse_counter_reset("a 1 b 2 c 3").unwrap();

        assert_eq!(r.counter_name.as_str(), "a");

        assert_eq!(r.value, 1);

        // ...the parse errors instead of falling back to a default when the

        // second token is not an integer.

        parse_counter_increment("a b").unwrap_err();

    }

    #[test]

    fn counter_arbitrary_whitespace_forms_are_normalized() {

        for input in [

            "\t page \n 42 \r",

            "page\u{a0}42",   // NBSP separates under split_whitespace

            "page    42",     // runs of spaces

            "\u{2003}page 42", // em-space

        ] {

            let r = parse_counter_reset(input).unwrap();

            assert_eq!(r.counter_name.as_str(), "page", "for {input:?}");

            assert_eq!(r.value, 42, "for {input:?}");

        }

    }

    #[test]

    fn counter_unicode_names_are_preserved() {

        let r = parse_counter_reset("\u{7ae0}\u{8282} 3").unwrap();

        assert_eq!(r.counter_name.as_str(), "\u{7ae0}\u{8282}");

        assert_eq!(r.value, 3);

        let i = parse_counter_increment("\u{1F600}").unwrap();

        assert_eq!(i.counter_name.as_str(), "\u{1F600}");

        assert_eq!(i.value, 1);

        // A zero-width space is not whitespace: it becomes a counter name.

        let z = parse_counter_reset("\u{200b}").unwrap();

        assert_eq!(z.counter_name.as_str(), "\u{200b}");

        assert_eq!(z.value, 0);

    }

    #[test]

    fn counter_hostile_corpus_never_panics() {

        for input in hostile_corpus() {

            let _ = parse_counter_reset(&input);

            let _ = parse_counter_increment(&input);

        }

    }

    #[test]

    fn counter_extremely_long_input_does_not_hang() {

        let long_name = "n".repeat(1_000_000);

        let r = parse_counter_reset(&long_name).unwrap();

        assert_eq!(r.counter_name.as_str().len(), 1_000_000);

        assert_eq!(r.value, 0);

        let with_value = alloc::format!("{long_name} 5");

        assert_eq!(parse_counter_increment(&with_value).unwrap().value, 5);

        // A million digits must be rejected, not truncated or wrapped.

        let long_number = alloc::format!("c {}", "9".repeat(1_000_000));

        assert!(parse_counter_reset(&long_number).is_err());

        // Whitespace-only input of the same size is still just an error.

        assert!(parse_counter_reset(&" ".repeat(1_000_000)).is_err());

    }

    #[test]

    fn counter_deeply_nested_input_does_not_stack_overflow() {

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

        let r = parse_counter_reset(&nested).unwrap();

        assert_eq!(r.counter_name.as_str().len(), 20_000);

        assert_eq!(r.value, 0);

        let nested_with_value = alloc::format!("{nested} 1");

        assert_eq!(parse_counter_increment(&nested_with_value).unwrap().value, 1);

    }

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

    // PrintAsCssValue <-> parser round-trips

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

    #[test]

    fn counter_print_parse_roundtrips_for_well_formed_values() {

        for (name, value) in [

            ("page", 0),

            ("page", 1),

            ("section", -1),

            ("list-item", i32::MAX),

            ("list-item", i32::MIN),

            ("\u{7ae0}", 7),

        ] {

            let r = CounterReset::new(name.into(), value);

            assert_eq!(parse_counter_reset(&r.print_as_css_value()).unwrap(), r);

            let i = CounterIncrement::new(name.into(), value);

            assert_eq!(parse_counter_increment(&i.print_as_css_value()).unwrap(), i);

        }

        // `none`/`list_item` constants also survive a full round-trip.

        let n = CounterReset::none();

        assert_eq!(n.print_as_css_value(), "none");

        assert_eq!(parse_counter_reset(&n.print_as_css_value()).unwrap(), n);

        let li = CounterIncrement::list_item();

        assert_eq!(li.print_as_css_value(), "list-item 1");

        assert_eq!(parse_counter_increment(&li.print_as_css_value()).unwrap(), li);

        assert_eq!(CounterReset::list_item().print_as_css_value(), "list-item 0");

        assert_eq!(CounterIncrement::none().print_as_css_value(), "none");

    }

    #[test]

    fn counter_print_of_empty_name_reparses_into_a_different_counter() {

        // An empty name prints as " 5"; re-parsing reads "5" as the *name*

        // and falls back to the default value -- a silent identity change.

        let r = CounterReset::new(AzString::from_const_str(""), 5);

        assert_eq!(r.print_as_css_value(), " 5");

        let reparsed = parse_counter_reset(&r.print_as_css_value()).unwrap();

        assert_eq!(reparsed.counter_name.as_str(), "5");

        assert_eq!(reparsed.value, 0);

        assert_ne!(reparsed, r);

    }

    #[test]

    fn counter_print_of_name_containing_space_fails_to_reparse() {

        // "a b" + " 5" prints as "a b 5"; the second token "b" is not an i32,

        // so the printed form is no longer parseable at all.

        let r = CounterReset::new("a b".into(), 5);

        assert_eq!(r.print_as_css_value(), "a b 5");

        assert!(parse_counter_reset(&r.print_as_css_value()).is_err());

        let i = CounterIncrement::new("a b".into(), 5);

        assert!(parse_counter_increment(&i.print_as_css_value()).is_err());

    }

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

    // Derived-trait invariants (Eq / Ord / Hash) and codegen formatting

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

    #[test]

    fn counter_ord_is_name_then_value_and_hash_agrees_with_eq() {

        let a1 = CounterReset::new("a".into(), 1);

        let a2 = CounterReset::new("a".into(), 2);

        let b_min = CounterReset::new("b".into(), i32::MIN);

        assert!(a1 < a2, "equal names must order by value");

        assert!(a2 < b_min, "name must dominate value in the ordering");

        assert!(CounterReset::new("a".into(), i32::MAX) < b_min);

        // Eq/Hash consistency, including across differently-allocated names.

        let owned = CounterReset::new(String::from("a").into(), 1);

        assert_eq!(owned, a1);

        assert_eq!(hash_of(&owned), hash_of(&a1));

        assert_ne!(a1, a2);

        assert_eq!(

            hash_of(&Content {

                inner: "x".into()

            }),

            hash_of(&parse_content(" x ").unwrap())

        );

    }

    #[test]

    fn format_as_rust_code_escapes_quotes_and_control_chars() {

        let c = Content {

            inner: "a\"b\\c\nd".into(),

        };

        assert_eq!(

            c.format_as_rust_code(0),

            r#"Content { inner: String::from("a\"b\\c\nd") }"#

        );

        let s = StringSet {

            inner: "\"q\"".into(),

        };

        assert_eq!(

            s.format_as_rust_code(0),

            r#"StringSet { inner: String::from("\"q\"") }"#

        );

        let r = CounterReset::new("a\"b".into(), i32::MIN);

        assert_eq!(

            r.format_as_rust_code(0),

            r#"CounterReset { counter_name: AzString::from_const_str("a\"b"), value: -2147483648 }"#

        );

        let i = CounterIncrement::new("".into(), i32::MAX);

        assert_eq!(

            i.format_as_rust_code(0),

            r#"CounterIncrement { counter_name: AzString::from_const_str(""), value: 2147483647 }"#

        );

    }

    #[test]

    fn format_as_rust_code_ignores_the_tab_argument() {

        let c = Content::default();

        assert_eq!(c.format_as_rust_code(0), c.format_as_rust_code(usize::MAX));

        let r = CounterReset::list_item();

        assert_eq!(r.format_as_rust_code(0), r.format_as_rust_code(usize::MAX));

    }

}