config-disassembler 0.11.0

//! XML parser that preserves CDATA sections.
//! Uses quick-xml directly to distinguish CDATA from regular text.
//!
//! In quick-xml 0.38+, entity references (", ", etc.) are emitted as
//! Event::GeneralRef. We accumulate raw text + entity refs, then unescape once
//! to preserve whitespace between entities (quick-xml can drop spaces when
//! emitting Text/GeneralRef separately).

use quick_xml::escape::unescape;
use quick_xml::events::Event;
use quick_xml::Reader;
use quick_xml::XmlVersion;
use serde_json::{Map, Value};

/// Append raw entity reference to buffer (e.g. "quot" -> """).
fn append_entity_to_raw(ref_: &quick_xml::events::BytesRef<'_>, raw: &mut String) {
    raw.push('&');
    raw.push_str(ref_.as_ref());
    raw.push(';');
}

/// Append CDATA content to the current element's "#cdata" buffer. Silently noops when the
/// stack is empty; quick-xml rejects CDATA outside an element before reaching this point.
fn append_cdata_to_current(stack: &mut [(String, Map<String, Value>)], content: &str) {
    if let Some((_, elem)) = stack.last_mut() {
        let merged = match elem.get("#cdata").and_then(|v| v.as_str()) {
            Some(prev) => format!("{}{}", prev, content),
            None => content.to_string(),
        };
        elem.insert("#cdata".to_string(), Value::String(merged));
    }
}

/// Append comment content to the current element's "#comment" buffer. Mirrors
/// `append_cdata_to_current`: multiple sibling `<!--...-->` comments under the same
/// element accumulate into one string rather than the second overwriting the first
/// (the previous behavior via a plain `insert`), the same way multiple adjacent CDATA
/// sections and multiple text runs between comments (`#text-tail`) already concatenate
/// rather than clobber. Silently noops when the stack is empty; quick-xml rejects a
/// comment outside an element before reaching this point.
fn append_comment_to_current(stack: &mut [(String, Map<String, Value>)], content: &str) {
    if let Some((_, elem)) = stack.last_mut() {
        let merged = match elem.get("#comment").and_then(|v| v.as_str()) {
            Some(prev) => format!("{}{}", prev, content),
            None => content.to_string(),
        };
        elem.insert("#comment".to_string(), Value::String(merged));
    }
}

/// Attach a finished child element (from Event::End or Event::Empty) to its parent -
/// or record it as the root when the stack is empty.
fn attach_child_to_parent(
    stack: &mut [(String, Map<String, Value>)],
    name: String,
    value: Value,
    root_name: &mut Option<String>,
    root_value: &mut Option<Value>,
) {
    let Some((_, parent)) = stack.last_mut() else {
        *root_name = Some(name);
        *root_value = Some(value);
        return;
    };
    match parent.get_mut(&name) {
        Some(Value::Array(arr)) => arr.push(value),
        Some(_) => {
            let prev = parent.remove(&name).expect("key checked above");
            parent.insert(name, Value::Array(vec![prev, value]));
        }
        None => {
            parent.insert(name, value);
        }
    }
}

/// Flush accumulated raw text buffer: unescape entities and add to current element.
fn flush_text_buffer(
    raw: &mut String,
    stack: &mut [(String, Map<String, Value>)],
    is_after_comment: bool,
) {
    if raw.is_empty() {
        return;
    }
    let text = unescape(raw.as_str()).unwrap_or_default().into_owned();
    raw.clear();
    if text.is_empty() {
        return;
    }
    let val_raw = Value::String(text.clone());
    let Some((_, elem)) = stack.last_mut() else {
        return;
    };
    // A text run that is entirely whitespace, appended onto content #text/#text-tail
    // already accumulated for this element, is pure inter-tag formatting (e.g. the
    // indentation the writer itself inserted between two shard-level tags) - it must
    // not grow the stored value, or every subsequent parse of the writer's own output
    // re-absorbs and re-emits it, growing without bound. A whitespace-only *first* run
    // (the `else` branches below) is still stored as-is: that's the existing, accepted
    // behavior for e.g. leading indentation before a child element captured as an
    // element's own #text (see the CDATA/comment-adjacent tests elsewhere in this file).
    let is_whitespace_only_run = text.trim().is_empty();

    if is_after_comment {
        match elem
            .get_mut("#text-tail")
            .and_then(|v| v.as_str())
            .map(str::to_string)
        {
            Some(prev) => {
                if !is_whitespace_only_run {
                    if prev.trim().is_empty() {
                        // The accumulated #text-tail so far is itself pure formatting
                        // (e.g. indentation the writer inserted between two tags with
                        // nothing meaningful between them yet) - see the #text branch
                        // below for the full explanation of why this must replace
                        // rather than concatenate, and why the *leading* whitespace of
                        // the replacement itself is trimmed too.
                        elem.insert(
                            "#text-tail".to_string(),
                            Value::String(text.trim_start().to_string()),
                        );
                    } else if let Some(b) = val_raw.as_str() {
                        elem.insert(
                            "#text-tail".to_string(),
                            Value::String(format!("{}{}", prev, b)),
                        );
                    }
                }
            }
            None => {
                elem.insert("#text-tail".to_string(), val_raw);
            }
        }
    } else if let Some(prev) = elem
        .get("#text")
        .and_then(|v| v.as_str())
        .map(str::to_string)
    {
        // This branch also covers what used to be a separate `elem.contains_key
        // ("#cdata")` case that unconditionally overwrote #text - e.g. for
        // `<a>real<![CDATA[x]]>tail</a>`, "real" is flushed into #text as the first
        // run *before* the CDATA event runs (#cdata isn't set yet), so the old
        // dedicated branch's blind `insert` on the trailing "tail" flush silently
        // discarded "real" the moment #cdata became present. Falling through to this
        // append-or-replace logic uniformly (whether or not #cdata is set) handles
        // both orderings correctly: cdata-then-trailing-whitespace still lands in
        // #text exactly as before (no prior #text to preserve), and
        // text-then-cdata-then-trailing-whitespace now keeps the earlier real text.
        //
        // Was `val_parsed.as_str()`: parse_text_value() trims before type-inferring, so
        // e.g. a second text run "( " (real trailing space) got silently trimmed to "("
        // when appended onto an earlier whitespace-only run (typical: leading indent
        // before a child tag, flushed into #text first). Worse, a purely-numeric/bool
        // second run (e.g. "42") would infer to a non-string Value, `.as_str()` would
        // return None, and the whole append would silently no-op, losing it entirely.
        // val_raw is always Some(the untrimmed text) - matches the #text-tail branch
        // above and the "first text run" branch below. Guarded by
        // `is_whitespace_only_run` for the same reason as #text-tail above.
        //
        // Additionally: if `prev` (the #text accumulated so far) is itself pure
        // whitespace - typically indentation flushed before a child element, which on
        // its own would have been stripped later as insignificant (strip_whitespace.rs)
        // - concatenating real content onto it permanently bakes that whitespace into
        // the merged value, where the later stripping pass can no longer tell it apart
        // from real content and never removes it. On the next disassemble/reassemble
        // cycle the writer regenerates its own equivalent separator whitespace *in
        // addition* to this now-permanent prefix, so the file gains one more copy of
        // it every round trip. Replacing rather than concatenating in this case
        // (identical reasoning for #text-tail above) drops the meaningless prefix
        // instead of durably fusing it to the data.
        //
        // The replacement itself is also trimmed on its *leading* edge only (trailing
        // whitespace is real - see the "( " test above): this run reached the parser
        // as a single, unbroken slice of character data with no intervening tag (that's
        // exactly why it's here, in the "already have a #text" branch, rather than
        // being its own separate flush), so any leading whitespace on it is exactly as
        // indistinguishable from formatting as `prev` was. Left untrimmed, the writer's
        // own unconditional separator after the child-elements block collides with this
        // run's baked-in leading whitespace and doubles up on every subsequent
        // disassemble/reassemble cycle - the same unbounded-growth failure mode as
        // `prev` itself, just one write/read cycle later.
        if !is_whitespace_only_run {
            if prev.trim().is_empty() {
                elem.insert(
                    "#text".to_string(),
                    Value::String(text.trim_start().to_string()),
                );
            } else if let Some(b) = val_raw.as_str() {
                elem.insert("#text".to_string(), Value::String(format!("{}{}", prev, b)));
            }
        }
    } else {
        elem.insert("#text".to_string(), val_raw);
    }
}

/// Parse XML string to JSON Value, preserving CDATA as #cdata key.
/// Produces the same structure as quickxml_to_serde but with #cdata for CDATA content.
pub fn parse_xml_with_cdata(xml: &str) -> Result<Value, quick_xml::Error> {
    let mut reader = Reader::from_str(xml);
    reader.config_mut().trim_text(false);

    let mut stack: Vec<(String, Map<String, Value>)> = Vec::new();
    let mut root_name: Option<String> = None;
    let mut root_value: Option<Value> = None;
    let mut text_buffer = String::new();
    let mut text_buffer_after_comment = false;

    let mut buf = Vec::new();
    loop {
        match reader.read_event_into(&mut buf) {
            Ok(Event::Start(e)) => {
                flush_text_buffer(&mut text_buffer, &mut stack, text_buffer_after_comment);
                text_buffer_after_comment = false;
                let name = e.name().as_ref().to_string();
                let mut attrs = Map::new();
                for a in e.attributes().flatten() {
                    let key = format!("@{}", a.key.as_ref());
                    let val = a
                        .normalized_value(XmlVersion::Implicit1_0)
                        .unwrap_or_default();
                    attrs.insert(key, Value::String(val.to_string()));
                }
                stack.push((name, attrs));
            }
            Ok(Event::End(_e)) => {
                flush_text_buffer(&mut text_buffer, &mut stack, text_buffer_after_comment);
                text_buffer_after_comment = false;
                // `stack.pop()` only returns None on malformed XML, which quick-xml rejects
                // before reaching here; silently skip when it does.
                if let Some((popped_name, elem)) = stack.pop() {
                    attach_child_to_parent(
                        &mut stack,
                        popped_name,
                        Value::Object(elem),
                        &mut root_name,
                        &mut root_value,
                    );
                }
            }
            Ok(Event::Empty(e)) => {
                flush_text_buffer(&mut text_buffer, &mut stack, text_buffer_after_comment);
                text_buffer_after_comment = false;
                let name = e.name().as_ref().to_string();
                let mut attrs = Map::new();
                for a in e.attributes().flatten() {
                    let key = format!("@{}", a.key.as_ref());
                    let val = a
                        .normalized_value(XmlVersion::Implicit1_0)
                        .unwrap_or_default();
                    attrs.insert(key, Value::String(val.to_string()));
                }
                attach_child_to_parent(
                    &mut stack,
                    name,
                    Value::Object(attrs),
                    &mut root_name,
                    &mut root_value,
                );
            }
            Ok(Event::Text(e)) => {
                // Deliberately does NOT touch `text_buffer_after_comment` here. It used
                // to be re-derived on every Text event as `elem.contains_key("#comment")`,
                // which is a stale, persistent check (the key is never removed) rather
                // than "did a comment immediately precede this text". That misrouted
                // trailing whitespace after `<!--c--><![CDATA[x]]>` into `#text-tail`
                // (comment-shaped) instead of `#text` (cdata-shaped), even though the
                // CDATA handler below had already reset the flag to false - re-parsing
                // the disassembled output then re-triggered the same misroute, growing
                // an extra blank #text-tail line on every successive round trip. The
                // flag is now a proper transient signal: Comment sets it true, every
                // other event that can intervene (Start/End/Empty/CData) resets it false.
                text_buffer.push_str(e.as_ref());
            }
            Ok(Event::Comment(e)) => {
                flush_text_buffer(&mut text_buffer, &mut stack, text_buffer_after_comment);
                let content = e.as_ref().to_string();
                append_comment_to_current(&mut stack, &content);
                text_buffer_after_comment = true;
            }
            Ok(Event::GeneralRef(ref_)) => {
                append_entity_to_raw(&ref_, &mut text_buffer);
            }
            Ok(Event::CData(e)) => {
                flush_text_buffer(&mut text_buffer, &mut stack, text_buffer_after_comment);
                text_buffer_after_comment = false;
                append_cdata_to_current(&mut stack, e.as_ref());
            }
            Ok(Event::Eof) => break,
            Ok(_) => {}
            Err(e) => return Err(e),
        }
        buf.clear();
    }

    if let (Some(name), Some(value)) = (root_name, root_value) {
        let mut root = Map::new();
        root.insert(name, value);
        Ok(Value::Object(root))
    } else {
        Ok(Value::Object(Map::new()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn append_cdata_to_current_noops_on_empty_stack() {
        // Defensive path: CDATA emitted with no open element (unreachable via quick-xml but
        // the helper still handles it gracefully without panicking).
        let mut stack: Vec<(String, Map<String, Value>)> = Vec::new();
        append_cdata_to_current(&mut stack, "ignored");
        assert!(stack.is_empty());
    }

    #[test]
    fn append_cdata_to_current_sets_and_appends() {
        // First call sets `#cdata`; second call appends (covers both match arms).
        let mut stack: Vec<(String, Map<String, Value>)> = vec![("r".to_string(), Map::new())];
        append_cdata_to_current(&mut stack, "one");
        append_cdata_to_current(&mut stack, "two");
        let (_, elem) = stack.last().unwrap();
        assert_eq!(elem.get("#cdata").and_then(|v| v.as_str()), Some("onetwo"));
    }

    #[test]
    fn append_comment_to_current_noops_on_empty_stack() {
        // Defensive path: a comment emitted with no open element (unreachable via
        // quick-xml but the helper still handles it gracefully without panicking).
        let mut stack: Vec<(String, Map<String, Value>)> = Vec::new();
        append_comment_to_current(&mut stack, "ignored");
        assert!(stack.is_empty());
    }

    #[test]
    fn append_comment_to_current_sets_and_appends() {
        // First call sets `#comment`; second call appends (covers both match arms).
        let mut stack: Vec<(String, Map<String, Value>)> = vec![("r".to_string(), Map::new())];
        append_comment_to_current(&mut stack, "first");
        append_comment_to_current(&mut stack, "second");
        let (_, elem) = stack.last().unwrap();
        assert_eq!(
            elem.get("#comment").and_then(|v| v.as_str()),
            Some("firstsecond")
        );
    }

    #[test]
    fn parse_xml_with_cdata_simple_element() {
        let xml = r#"<root><a>hello</a></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        let a = root.get("a").and_then(|a| a.as_object()).unwrap();
        assert_eq!(a.get("#text").and_then(|t| t.as_str()), Some("hello"));
    }

    #[test]
    fn parse_xml_with_cdata_preserves_cdata() {
        let xml = r#"<root><x><![CDATA[<escaped>]]></x></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        let x = root.get("x").and_then(|x| x.as_object()).unwrap();
        assert_eq!(x.get("#cdata").and_then(|c| c.as_str()), Some("<escaped>"));
    }

    #[test]
    fn parse_xml_with_cdata_empty_element() {
        let xml = r#"<root><empty/></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        assert!(root.get("empty").is_some());
    }

    #[test]
    fn parse_xml_with_cdata_comment() {
        let xml = r#"<root><!-- comment --><a>1</a></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        assert!(root.get("#comment").or(root.get("a")).is_some());
    }

    #[test]
    fn parse_xml_with_cdata_attributes() {
        let xml = r#"<root id="x"><a>1</a></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        assert_eq!(root.get("@id").and_then(|v| v.as_str()), Some("x"));
    }

    #[test]
    fn parse_xml_with_cdata_multiple_children() {
        let xml = r#"<r><n>42</n><b>true</b></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        assert!(r.get("n").is_some());
        assert!(r.get("b").is_some());
    }

    #[test]
    fn parse_xml_with_cdata_text_tail_after_comment() {
        let xml = r#"<r><!-- comment -->tail</r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        assert_eq!(
            r.get("#comment").and_then(|c| c.as_str()),
            Some(" comment ")
        );
        assert_eq!(r.get("#text-tail").and_then(|t| t.as_str()), Some("tail"));
    }

    #[test]
    fn parse_xml_with_cdata_empty_root_returns_empty_object() {
        let xml = r#"<root></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        assert!(root.is_empty());
    }

    #[test]
    fn parse_xml_with_cdata_mixed_content_appends_text() {
        // Two text nodes in same element (e.g. <a>hello</a><b/> then text "world" in same parent)
        let xml = r#"<r><a>hello<x/>world</a></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        let a = r.get("a").and_then(|a| a.as_object()).unwrap();
        // First text "hello", then after <x/>, text "world" appends to #text
        assert!(a.get("#text").is_some());
        let t = a.get("#text").and_then(|t| t.as_str()).unwrap();
        assert!(t.contains("hello") && t.contains("world"));
    }

    #[test]
    fn parse_xml_with_cdata_appends_multiple_cdata_sections() {
        let xml = r#"<r><x><![CDATA[a]]><![CDATA[b]]></x></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let x = v
            .get("r")
            .and_then(|r| r.get("x"))
            .and_then(|x| x.as_object())
            .unwrap();
        assert_eq!(x.get("#cdata").and_then(|c| c.as_str()), Some("ab"));
    }

    #[test]
    fn parse_xml_with_cdata_invalid_returns_err() {
        let result = parse_xml_with_cdata("<<");
        assert!(result.is_err());
    }

    #[test]
    fn parse_xml_with_cdata_duplicate_sibling_elements_become_array() {
        let xml = r#"<r><item>a</item><item>b</item></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        let items = r.get("item").and_then(|i| i.as_array()).unwrap();
        assert_eq!(items.len(), 2);
        assert_eq!(items[0].get("#text").and_then(|t| t.as_str()), Some("a"));
        assert_eq!(items[1].get("#text").and_then(|t| t.as_str()), Some("b"));
    }

    #[test]
    fn parse_xml_with_cdata_empty_element_with_attributes() {
        let xml = r#"<r><empty id="x"/></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let empty = v
            .get("r")
            .and_then(|r| r.get("empty"))
            .and_then(|e| e.as_object())
            .unwrap();
        assert_eq!(empty.get("@id").and_then(|v| v.as_str()), Some("x"));
    }

    #[test]
    fn parse_xml_with_cdata_duplicate_empty_siblings_become_array() {
        // Two empty elements with same name: second triggers remove+insert Array (Event::End path)
        let xml = r#"<r><a/><a/></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        let arr = r.get("a").and_then(|a| a.as_array()).unwrap();
        assert_eq!(arr.len(), 2);
    }

    #[test]
    fn parse_xml_with_cdata_malformed_entity_between_tags_is_dropped() {
        // A bare `&;` unescapes to an empty string - second empty-check returns without insert.
        let v = parse_xml_with_cdata(r#"<r>&;</r>"#).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        // Text collapses to nothing - no #text key
        assert!(r.get("#text").is_none());
    }

    #[test]
    fn parse_xml_with_cdata_empty_root_element() {
        // Self-closing root: Event::Empty at the top level (no parent on stack).
        let v = parse_xml_with_cdata("<root/>").unwrap();
        let root = v.get("root").and_then(|r| r.as_object()).unwrap();
        assert!(root.is_empty());
    }

    #[test]
    fn parse_xml_with_cdata_three_empty_siblings_extend_array() {
        // Third duplicate empty sibling extends the existing array.
        let v = parse_xml_with_cdata("<r><a/><a/><a/></r>").unwrap();
        let arr = v
            .get("r")
            .and_then(|r| r.get("a"))
            .and_then(|a| a.as_array())
            .unwrap();
        assert_eq!(arr.len(), 3);
    }

    #[test]
    fn parse_xml_with_cdata_text_tail_appended_after_second_comment() {
        // Comment then text (#text-tail), then comment then text -> append to #text-tail
        let xml = r#"<r><!--c1-->t1<!--c2-->t2</r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        assert_eq!(r.get("#text-tail").and_then(|t| t.as_str()), Some("t1t2"));
    }

    #[test]
    fn parse_xml_with_cdata_empty_document_returns_empty_object() {
        // Eof with no root (e.g. empty or only whitespace) -> empty object
        let xml = r#""#;
        let v = parse_xml_with_cdata(xml).unwrap();
        assert!(v.as_object().unwrap().is_empty());
    }

    #[test]
    fn parse_xml_with_cdata_text_after_cdata_stored_as_text() {
        // CDATA followed by regular text in the same element hits the
        // `elem.contains_key("#cdata")` branch in flush_text_buffer (line 126 path).
        let xml = r#"<root><item><![CDATA[raw content]]>extra text</item></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let item = v
            .get("root")
            .and_then(|r| r.get("item"))
            .and_then(|i| i.as_object())
            .unwrap();
        assert_eq!(
            item.get("#cdata").and_then(|c| c.as_str()),
            Some("raw content")
        );
        // The text after CDATA is stored under #text (raw string value)
        assert!(
            item.get("#text").is_some(),
            "text after CDATA must be stored as #text"
        );
    }

    #[test]
    fn parse_xml_with_cdata_text_after_comment_then_cdata_stored_as_text_not_tail() {
        // A comment immediately followed by CDATA, then trailing whitespace/text before
        // the closing tag: the CDATA event resets `text_buffer_after_comment` to false,
        // so the trailing text must land in `#text` (cdata-shaped), not `#text-tail`
        // (comment-shaped) - `elem.contains_key("#comment")` staying true forever
        // (the key is never removed) used to re-derive the flag as true on the Text
        // event regardless, misrouting it and causing an extra #text-tail line to
        // reappear (and grow) on every subsequent disassemble/reassemble cycle.
        let xml = r#"<root><item><!--c--><![CDATA[x]]>tail</item></root>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let item = v
            .get("root")
            .and_then(|r| r.get("item"))
            .and_then(|i| i.as_object())
            .unwrap();
        assert_eq!(item.get("#comment").and_then(|c| c.as_str()), Some("c"));
        assert_eq!(item.get("#cdata").and_then(|c| c.as_str()), Some("x"));
        assert_eq!(item.get("#text").and_then(|t| t.as_str()), Some("tail"));
        assert!(
            item.get("#text-tail").is_none(),
            "trailing text after comment+CDATA must not be misrouted to #text-tail"
        );
    }

    #[test]
    fn parse_xml_with_cdata_unescapes_entities_in_text() {
        // quick-xml 0.38+ emits entities as Event::GeneralRef; we resolve and append.
        let xml = r#"<r><expr>IF(x, &quot;created&quot;, &quot;updated&quot;)</expr></r>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let r = v.get("r").and_then(|r| r.as_object()).unwrap();
        let expr = r.get("expr").and_then(|e| e.as_object()).unwrap();
        let text = expr.get("#text").and_then(|t| t.as_str()).unwrap();
        // Must have actual quote chars so round-trip produces &quot; in output
        assert!(text.contains(r#""created""#) && text.contains(r#""updated""#));
    }

    #[test]
    fn parse_xml_with_cdata_preserves_space_after_comma_in_entities() {
        // Fixture format: comma space before second entity - must preserve for round-trip
        let xml = r#"<e>IF(a, &quot;x&quot;, &quot;y&quot;)</e>"#;
        let v = parse_xml_with_cdata(xml).unwrap();
        let e = v.get("e").and_then(|e| e.as_object()).unwrap();
        let text = e.get("#text").and_then(|t| t.as_str()).unwrap();
        assert_eq!(
            text, r#"IF(a, "x", "y")"#,
            "space after comma must be preserved"
        );
    }
}