//! Hand-written minimal WordprocessingML fixtures (written for these tests from the spec).

use std::io::Write;
use std::sync::Arc;

use craft_wordmodel::fill::Fill;
use craft_wordmodel::para::{Anchor, FloatAlign, NoteKind, ShapeKind, Wrap};
use craft_wordmodel::props::{Align, Border, BorderStyle, Rgb, TextColor, Underline, VMerge};
use craft_wordmodel::{Block, Document, InlineObject, Paragraph, RevisionKind};

const W_NS: &str = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office""#;

const ROOT_RELS: &str = r#"<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>"#;

pub fn zip(entries: &[(&str, &[u8])]) -> Vec<u8> {
    let mut zw = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
    for (name, bytes) in entries {
        zw.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
        zw.write_all(bytes).unwrap();
    }
    zw.finish().unwrap().into_inner()
}

fn rels(list: &[(&str, &str, &str)]) -> String {
    let mut s = String::from(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">"#);
    for (id, ty, target) in list {
        let ext = if target.starts_with("http") { r#" TargetMode="External""# } else { "" };
        s.push_str(&format!(
            r#"<Relationship Id="{id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/{ty}" Target="{target}"{ext}/>"#
        ));
    }
    s.push_str("</Relationships>");
    s
}

/// A package with `body` as the document body and extra (path, content) parts.
fn docx(body: &str, doc_rels: &[(&str, &str, &str)], extra: &[(&str, &str)]) -> Vec<u8> {
    let doc = format!(r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document {W_NS}><w:body>{body}</w:body></w:document>"#);
    let r = rels(doc_rels);
    let mut entries: Vec<(&str, &[u8])> =
        vec![("_rels/.rels", ROOT_RELS.as_bytes()), ("word/document.xml", doc.as_bytes()), ("word/_rels/document.xml.rels", r.as_bytes())];
    for (p, c) in extra {
        entries.push((p, c.as_bytes()));
    }
    zip(&entries)
}

fn read_body(body: &str) -> Document {
    craft_docx::read(&docx(body, &[], &[])).unwrap()
}

/// Markup compatibility replaces an AlternateContent wrapper with one selected branch,
/// including where a table expects rows or cells (ECMA-376 Part 3).
#[test]
fn table_alternate_content_keeps_selected_rows_and_cells() {
    let cell = |text: &str| format!("<w:tc><w:p><w:r><w:t>{text}</w:t></w:r></w:p></w:tc>");
    let row = |text: &str| format!("<w:tr>{}</w:tr>", cell(text));
    let table =
        |rows: &str, columns: usize| format!(r#"<w:tbl><w:tblGrid>{}</w:tblGrid>{rows}</w:tbl>"#, r#"<w:gridCol w:w="2400"/>"#.repeat(columns));
    let alternate = |chosen: &str, fallback: &str, requires: &str| {
        format!(
            r#"<mc:AlternateContent><mc:Choice Requires="{requires}">{chosen}</mc:Choice><mc:Fallback>{fallback}</mc:Fallback></mc:AlternateContent>"#
        )
    };
    for (requires, use_choice) in [("wps", true), ("alias", true), ("unknown", false), ("wps unknown", false)] {
        for cells in [false, true] {
            let choice = if cells { cell("Chosen cell") } else { row("Chosen row") };
            let fallback = if cells { cell("Fallback cell") } else { row("Fallback row") };
            let selected = if use_choice { &choice } else { &fallback };
            let middle = alternate(&choice, &fallback, requires);
            let (actual, expected) = if cells {
                (
                    format!("<w:tr>{}{middle}{}</w:tr>", cell("Before"), cell("After")),
                    format!("<w:tr>{}{selected}{}</w:tr>", cell("Before"), cell("After")),
                )
            } else {
                (format!("{}{middle}{}", row("Before"), row("After")), format!("{}{selected}{}", row("Before"), row("After")))
            };
            let columns = if cells { 3 } else { 1 };
            let expected = read_body(&table(&expected, columns));
            let wrapped = format!(
                r#"<w:customXml xmlns:alias="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:unknown="urn:original:unsupported">{}</w:customXml>"#,
                table(&actual, columns)
            );
            let mut actual = read_body(&wrapped);
            for round in 0..=2 {
                assert_eq!(actual.body, expected.body, "requires={requires}, cells={cells}, round={round}");
                if round < 2 {
                    actual = craft_docx::read(&craft_docx::write(&actual).unwrap()).unwrap();
                }
            }
        }
    }
}

#[test]
fn table_alternate_content_keeps_nested_row_and_cell_controls() {
    let wrap =
        |tag: &str, content: &str| format!(r#"<w:sdt><w:sdtPr><w:tag w:val="{tag}"/></w:sdtPr><w:sdtContent>{content}</w:sdtContent></w:sdt>"#);
    let alternate =
        |content: &str| format!(r#"<mc:AlternateContent><mc:Choice Requires="wps">{content}</mc:Choice><mc:Fallback/></mc:AlternateContent>"#);
    let cell = "<w:tc><w:p><w:r><w:t>Controlled cell</w:t></w:r></w:p></w:tc>";
    let oracle_cell = wrap("cell", cell);
    let actual_cell = alternate(&wrap("cell", &alternate(cell)));
    let oracle_row = wrap("row", &format!("<w:tr>{oracle_cell}</w:tr>"));
    let actual_row = wrap("row", &alternate(&format!("<w:tr>{actual_cell}</w:tr>")));
    let expected = read_body(&format!("<w:tbl>{oracle_row}</w:tbl>"));
    let mut actual = read_body(&format!("<w:tbl>{}</w:tbl>", alternate(&actual_row)));
    for round in 0..=2 {
        assert_eq!(actual.body, expected.body, "round={round}");
        let table = actual.body.iter().find_map(|b| b.as_table()).unwrap();
        assert_eq!(table.rows[0].controls.open[0].tag, "row");
        assert_eq!(table.rows[0].controls.close, 1);
        assert_eq!(table.rows[0].cells[0].controls.open[0].tag, "cell");
        assert_eq!(table.rows[0].cells[0].controls.close, 1);
        if round < 2 {
            actual = craft_docx::read(&craft_docx::write(&actual).unwrap()).unwrap();
        }
    }
}

#[test]
fn repeated_style_ids_use_last() {
    let styles = format!(
        r#"<w:styles {W_NS}>
        <w:style w:type="paragraph" w:styleId="Repeated"><w:name w:val="First"/>
          <w:pPr><w:spacing w:after="240"/></w:pPr><w:rPr><w:b/><w:smallCaps/><w:sz w:val="28"/></w:rPr>
        </w:style>
        <w:style w:type="paragraph" w:styleId="Repeated"><w:name w:val="Last"/>
          <w:pPr><w:spacing w:before="120"/></w:pPr><w:rPr><w:i/><w:caps/><w:sz w:val="20"/></w:rPr>
        </w:style></w:styles>"#
    );
    let bytes = docx(
        r#"<w:p><w:pPr><w:pStyle w:val="Repeated"/></w:pPr><w:r><w:t>Original style probe</w:t></w:r></w:p>"#,
        &[("styles", "styles", "styles.xml")],
        &[("word/styles.xml", &styles)],
    );
    let mut document = craft_docx::read(&bytes).unwrap();
    for round in 0..=2 {
        let style = document.styles.get("Repeated").unwrap();
        assert_eq!(style.name, "Last");
        assert_eq!(style.chr.size, Some(10.0));
        assert_eq!(style.chr.italic, Some(true));
        assert_eq!(style.chr.bold, None);
        assert_eq!(style.chr.caps, Some(true));
        assert_eq!(style.chr.small_caps, None);
        assert_eq!(style.para.space_before, Some(6.0));
        assert_eq!(style.para.space_after, None);
        assert_eq!(document.styles.styles.iter().filter(|style| style.id == "Repeated").count(), 1);
        if round < 2 {
            document = craft_docx::read(&craft_docx::write(&document).unwrap()).unwrap();
        }
    }
}

#[test]
fn paragraph_default_presence_survives_repeated_saves() {
    // Omission leaves paragraph defaults application-defined (ISO 29500 pPrDefault).
    // An explicitly empty container must therefore remain distinct from omission.
    for (defaults, present, after) in [
        ("", false, None),
        ("<w:docDefaults/>", false, None),
        ("<w:docDefaults><w:rPrDefault><w:rPr><w:sz w:val=\"22\"/></w:rPr></w:rPrDefault></w:docDefaults>", false, None),
        ("<w:docDefaults><w:pPrDefault/></w:docDefaults>", true, None),
        ("<w:docDefaults><w:pPrDefault><w:pPr/></w:pPrDefault></w:docDefaults>", true, None),
        ("<w:docDefaults><w:pPrDefault><w:pPr><w:spacing w:after=\"160\"/></w:pPr></w:pPrDefault></w:docDefaults>", true, Some(8.0)),
    ] {
        let styles = format!(
            r#"<w:styles {W_NS}>{defaults}<w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style></w:styles>"#
        );
        let mut d = craft_docx::read(&docx(
            "<w:p><w:r><w:t>First</w:t></w:r></w:p><w:p><w:r><w:t>Second</w:t></w:r></w:p>",
            &[("rId1", "styles", "styles.xml")],
            &[("word/styles.xml", &styles)],
        ))
        .unwrap();
        for _ in 0..2 {
            let bytes = craft_docx::write(&d).unwrap();
            let xml = text(&unzip(&bytes), "word/styles.xml");
            assert_eq!(xml.contains("<w:pPrDefault>"), present, "{defaults}");
            d = craft_docx::read(&bytes).unwrap();
            assert_eq!(d.styles.default_para.space_after, after);
            assert_eq!(paras(&d).iter().map(|p| p.text.as_str()).collect::<Vec<_>>(), ["First", "Second"]);
        }
    }
}

#[test]
fn zero_frame_keeps_normal_flow() {
    const ROUND_TRIPS: usize = 2;
    let zero = r#"<w:framePr w:w="0" w:h="0" w:xAlign="left" w:y="0" w:hRule="exact" w:vAnchor="margin"/>"#;
    let sized = r#"<w:framePr w:w="2400" w:h="1200" w:x="1440" w:y="2880" w:hAnchor="page" w:vAnchor="page" w:hRule="exact"/>"#;
    for frame in [zero, sized] {
        let styles = format!(
            r#"<w:styles {W_NS}><w:docDefaults><w:pPrDefault><w:pPr>{frame}<w:spacing w:after="160"/></w:pPr></w:pPrDefault></w:docDefaults>
            <w:style w:type="paragraph" w:styleId="Framed"><w:name w:val="Framed"/><w:pPr>{sized}</w:pPr></w:style></w:styles>"#
        );
        let header = format!(r#"<w:hdr {W_NS}><w:p><w:r><w:t>Header alpha</w:t></w:r></w:p><w:p><w:r><w:t>Header beta</w:t></w:r></w:p></w:hdr>"#);
        let footer = format!(r#"<w:ftr {W_NS}><w:p><w:r><w:t>Footer delta</w:t></w:r></w:p></w:ftr>"#);
        let body = format!(
            r#"<w:p><w:r><w:t>Body one</w:t></w:r></w:p>
            <w:p><w:pPr>{sized}</w:pPr><w:r><w:t>Direct frame</w:t></w:r></w:p>
            <w:p><w:pPr><w:pStyle w:val="Framed"/></w:pPr><w:r><w:t>Styled frame</w:t></w:r></w:p>
            <w:p><w:pPr><w:pStyle w:val="Framed"/>{zero}</w:pPr><w:r><w:t>Frame reset</w:t></w:r></w:p>
            <w:sectPr><w:headerReference w:type="default" r:id="header"/><w:footerReference w:type="default" r:id="footer"/></w:sectPr>"#
        );
        let mut document = craft_docx::read(&docx(
            &body,
            &[("styles", "styles", "styles.xml"), ("header", "header", "header1.xml"), ("footer", "footer", "footer1.xml")],
            &[("word/styles.xml", &styles), ("word/header1.xml", &header), ("word/footer1.xml", &footer)],
        ))
        .unwrap();
        for pass in 0..=ROUND_TRIPS {
            let body = paras(&document);
            let resolved = document.styles.resolve_para(&body[0].props);
            assert!(resolved.frame.is_none(), "document defaults never create a frame");
            assert!(document.styles.default_para.frame.is_none());
            let reset = body[3].props.frame.as_ref().unwrap();
            assert_eq!((reset.w, reset.h), (Some(0.0), Some(0.0)), "the direct reset survives saving");
            assert_eq!(resolved.space_after, 8.0);
            assert!(document.styles.resolve_para(&body[1].props).frame.is_some());
            assert!(document.styles.resolve_para(&body[2].props).frame.is_some());
            assert!(document.styles.resolve_para(&body[3].props).frame.is_none());
            for id in [document.last_section.headers.default, document.last_section.footers.default] {
                for block in &document.parts.get(&id.unwrap()).unwrap().blocks {
                    let paragraph = block.as_para().unwrap();
                    assert!(document.styles.resolve_para(&paragraph.props).frame.is_none(), "defaults do not frame headers or footers");
                }
            }
            if pass == ROUND_TRIPS {
                break;
            }
            document = craft_docx::read(&craft_docx::write(&document).unwrap()).unwrap();
        }
    }
}

#[test]
fn frame_zero_side_is_automatic() {
    for (attrs, width, height) in
        [(r#"w:w="0" w:h="1200""#, None, Some(60.0)), (r#"w:w="2400" w:h="0" w:hRule="exact""#, Some(120.0), None), ("", None, None)]
    {
        let document = read_body(&format!(r#"<w:p><w:pPr><w:framePr {attrs}/></w:pPr><w:r><w:t>Original automatic frame</w:t></w:r></w:p>"#));
        let paragraph = paras(&document)[0];
        let frame = document.styles.resolve_para(&paragraph.props).frame.unwrap();
        assert_eq!((frame.w, frame.h), (width, height));
    }
}

#[test]
fn locked_frame_anchor_survives_two_saves() {
    for (lock, expected) in [("", None), (" w:anchorLock=\"1\"", Some(true)), (" w:anchorLock=\"0\"", Some(false))] {
        let mut document = read_body(&format!(r#"<w:p><w:pPr><w:framePr w:w="1440" w:h="720"{lock}/></w:pPr><w:r><w:t>Locked</w:t></w:r></w:p>"#));
        let paragraph = paras(&document)[0];
        assert_eq!(paragraph.props.frame.as_ref().and_then(|f| f.anchor_lock), expected);
        if expected == Some(true) {
            let Some(craft_wordmodel::Block::Para(paragraph)) = document.body.get_mut(0).map(std::sync::Arc::make_mut) else {
                panic!("first block is the framed paragraph");
            };
            let frame = paragraph.props.frame.as_mut().unwrap();
            frame.x = 36.0;
            frame.y = 72.0;
            frame.w = Some(108.0);
        }
        let json = serde_json::to_vec(&document).unwrap();
        document = serde_json::from_slice(&json).unwrap();
        if expected == Some(true) {
            let frame = paras(&document)[0].props.frame.as_ref().unwrap();
            assert_eq!((frame.x, frame.y, frame.w), (36.0, 72.0, Some(108.0)));
        }
        for pass in 0..2 {
            let bytes = craft_docx::write(&document).unwrap();
            let xml = text(&unzip(&bytes), "word/document.xml");
            let expected_xml = match expected {
                Some(true) => "w:anchorLock=\"1\"",
                Some(false) => "w:anchorLock=\"0\"",
                None => "w:anchorLock=",
            };
            assert_eq!(xml.contains(expected_xml), expected.is_some(), "lock changed on save {}: {xml}", pass + 1);
            document = craft_docx::read(&bytes).unwrap();
            assert_eq!(paras(&document)[0].props.frame.as_ref().and_then(|f| f.anchor_lock), expected);
            if expected == Some(true) {
                let frame = paras(&document)[0].props.frame.as_ref().unwrap();
                assert_eq!((frame.x, frame.y, frame.w), (36.0, 72.0, Some(108.0)));
            }
        }
    }
}

#[test]
fn omitted_paragraph_defaults_can_be_edited() {
    let styles =
        format!(r#"<w:styles {W_NS}><w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style></w:styles>"#);
    let mut d = craft_docx::read(&docx("<w:p/>", &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    assert!(!d.styles.default_para_present);
    Arc::make_mut(&mut d.styles).default_para.space_after = Some(12.0);
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert!(again.styles.default_para_present);
    assert_eq!(again.styles.default_para.space_after, Some(12.0));
    let new = Document::new();
    assert_eq!(craft_docx::read(&craft_docx::write(&new).unwrap()).unwrap().styles.default_para, new.styles.default_para);
}

fn paras(d: &Document) -> Vec<&Paragraph> {
    d.body.iter().filter_map(|b| b.as_para()).collect()
}

#[test]
fn ref_links_keep_cached_results() {
    let d = read_body(
        r#"
<w:p><w:fldSimple w:instr="REF destination \h" w:fldLock="1"><w:r><w:rPr><w:b/></w:rPr><w:t>Cached simple</w:t></w:r></w:fldSimple></w:p>
<w:p><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve">REF destination </w:instrText></w:r><w:r><w:instrText>\w \h</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:t>Cached complex</w:t></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r></w:p>
<w:p><w:bookmarkStart w:id="0" w:name="destination"/><w:r><w:t>Changed destination</w:t></w:r><w:bookmarkEnd w:id="0"/></w:p>"#,
    );
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    for doc in [&d, &again] {
        let p = paras(doc);
        for (index, instr, cached, locked) in
            [(0, r"REF destination \h", "Cached simple", true), (1, r"REF destination \w \h", "Cached complex", false)]
        {
            assert!(matches!(&p[index].objects[0], InlineObject::Field { instr: actual, result, locked: lock, .. }
                if actual == instr && result == cached && *lock == locked));
        }
        assert_eq!(p[0].props_of_char(0).bold, Some(true));
        assert!(doc.bookmarks().iter().any(|(name, _)| name == "destination"));
    }
}

#[test]
fn single_entry_toc_keeps_formatted_result_and_nested_page_field() {
    let d = read_body(
        r#"
<w:p><w:pPr><w:pStyle w:val="TOCHeading"/></w:pPr><w:r><w:t>Contents</w:t></w:r></w:p>
<w:p><w:pPr><w:pStyle w:val="TOC1"/></w:pPr>
 <w:r><w:fldChar w:fldCharType="begin" w:fldLock="true"/></w:r>
 <w:r><w:instrText> TOC \o "1-1" \h </w:instrText></w:r>
 <w:r><w:fldChar w:fldCharType="separate"/></w:r>
 <w:hyperlink w:anchor="_Toc1"><w:r><w:rPr><w:b/></w:rPr><w:t>Intro</w:t></w:r>
 <w:r><w:tab/></w:r><w:fldSimple w:instr=" PAGEREF _Toc1 \h "><w:r><w:t>1</w:t></w:r></w:fldSimple></w:hyperlink>
 <w:r><w:fldChar w:fldCharType="end"/></w:r>
</w:p>"#,
    );
    let p = paras(&d);
    assert_eq!(p[0].plain_text(), "Contents");
    assert_eq!(
        p[0].objects,
        vec![InlineObject::Field {
            instr: r#"TOC \o "1-1" \h"#.into(),
            result: String::new(),
            locked: true,
            dirty: false,
            code: false,
            form: String::new()
        }]
    );
    assert_eq!(p[1].plain_text(), "Intro\t1");
    assert_eq!(p[1].props_of_char(0).bold, Some(true));
    assert_eq!(p[1].props_of_char(0).link.as_deref(), Some("#_Toc1"));
    assert_eq!(
        p[1].objects,
        vec![InlineObject::Field {
            instr: r#"PAGEREF _Toc1 \h"#.into(),
            result: "1".into(),
            locked: false,
            dirty: false,
            code: false,
            form: String::new()
        }]
    );
}

#[test]
fn toc_complex_field_spanning_paragraphs() {
    let body = r#"
<w:p><w:pPr><w:pStyle w:val="TOC1"/></w:pPr>
 <w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> TOC \o "1-3" \h \z \u </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>
 <w:hyperlink w:anchor="_Toc1"><w:r><w:t>Intro</w:t></w:r><w:r><w:tab/></w:r><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> PAGEREF _Toc1 \h </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:t>1</w:t></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r></w:hyperlink>
</w:p>
<w:p><w:hyperlink w:anchor="_Toc2"><w:r><w:t>Body</w:t></w:r><w:r><w:tab/></w:r><w:r><w:t>2</w:t></w:r></w:hyperlink></w:p>
<w:p><w:r><w:fldChar w:fldCharType="end"/></w:r></w:p>
<w:p><w:bookmarkStart w:id="0" w:name="_Toc1"/><w:r><w:t>Intro</w:t></w:r><w:bookmarkEnd w:id="0"/></w:p>
<w:p><w:r><w:t xml:space="preserve">Page </w:t></w:r><w:fldSimple w:instr=" PAGE "><w:r><w:t>7</w:t></w:r></w:fldSimple></w:p>"#;
    let d = read_body(body);
    let p = paras(&d);
    assert_eq!(p.len(), 5);
    assert_eq!(p[0].text, "\u{FFFC}Intro\t\u{FFFC}");
    assert_eq!(p[0].objects[0], InlineObject::FieldStart { instr: r#"TOC \o "1-3" \h \z \u"#.into(), locked: false, dirty: false });
    assert_eq!(
        p[0].objects[1],
        InlineObject::Field {
            instr: r#"PAGEREF _Toc1 \h"#.into(),
            result: "1".into(),
            locked: false,
            dirty: false,
            code: false,
            form: String::new()
        }
    );
    assert_eq!(p[0].props_of_char(3).link.as_deref(), Some("#_Toc1"));
    assert_eq!(p[0].props.style.as_deref(), Some("TOC1"));
    assert_eq!(p[1].text, "Body\t2");
    assert_eq!(p[1].props_of_char(0).link.as_deref(), Some("#_Toc2"));
    assert_eq!(p[2].objects, vec![InlineObject::FieldEnd]);
    assert_eq!(p[3].objects, vec![InlineObject::BookmarkStart { name: "_Toc1".into() }, InlineObject::BookmarkEnd { name: "_Toc1".into() }]);
    assert_eq!(p[4].plain_text(), "Page 7");
    assert_eq!(
        p[4].objects[0],
        InlineObject::Field { instr: "PAGE".into(), result: "7".into(), locked: false, dirty: false, code: false, form: String::new() }
    );
    // And it writes back out and reads the same.
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(again.body, d.body);
}

#[test]
fn hyperlink_runs_and_wrappers() {
    let body = r#"
<w:p>
 <w:hyperlink r:id="rId5" w:history="1"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>site</w:t></w:r></w:hyperlink>
 <w:hyperlink r:id="rId5" w:anchor="frag"><w:r><w:t>X</w:t></w:r></w:hyperlink>
 <w:smartTag><w:r><w:t>A</w:t></w:r></w:smartTag><w:customXml><w:r><w:t>B</w:t></w:r></w:customXml>
 <w:sdt><w:sdtPr/><w:sdtContent><w:r><w:t>C</w:t></w:r></w:sdtContent></w:sdt>
 <w:r><w:sym w:font="Wingdings" w:char="F04A"/><w:noBreakHyphen/><w:softHyphen/><w:cr/><w:br w:type="page"/><w:br w:type="column"/><w:t xml:space="preserve"> e&amp;</w:t></w:r>
 <w:proofErr w:type="spellStart"/><w:r><w:rPr><w:b w:val="false"/><w:i w:val="0"/><w:caps w:val="off"/><w:strike w:val="true"/><w:color w:val="auto"/></w:rPr><w:t>T</w:t></w:r>
</w:p>
<w:sdt><w:sdtContent><w:p><w:r><w:t>in block sdt</w:t></w:r></w:p></w:sdtContent></w:sdt>"#;
    let bytes = docx(body, &[("rId5", "hyperlink", "https://example.org/")], &[]);
    let d = craft_docx::read(&bytes).unwrap();
    let p = paras(&d);
    // The content control around "C" is kept (zero-width markers in the text).
    assert_eq!(p[0].plain_text(), "siteXABC\u{F04A}\u{2011}\u{AD}\n\u{C}\u{E} e&T");
    assert!(matches!(p[0].objects.first(), Some(InlineObject::ControlStart { .. })));
    assert_eq!(p[0].props_of_char(0).link.as_deref(), Some("https://example.org/"));
    assert_eq!(p[0].props_of_char(0).style.as_deref(), Some("Hyperlink"));
    assert_eq!(p[0].props_of_char(4).link.as_deref(), Some("https://example.org/#frag"));
    let sym_off = p[0].text.find('\u{F04A}').unwrap();
    assert_eq!(p[0].props_of_char(sym_off).sym_font.as_deref(), Some("Wingdings"), "the symbol keeps its own font");
    let t = p[0].props_of_char(p[0].text.len() - 1);
    assert_eq!((t.bold, t.italic, t.caps, t.strike, t.color), (Some(false), Some(false), Some(false), Some(true), Some(TextColor::Auto)));
    assert_eq!(p[1].plain_text(), "in block sdt");
}

#[test]
fn symbol_font_text_reads_as_unicode_and_round_trips_unchanged() {
    // Wingdings stored both ways Word writes it: `w:sym` (private-use code) and a plain code in a
    // run whose font is Wingdings; plus Symbol and Webdings.
    let body = r#"
<w:p>
 <w:r><w:t xml:space="preserve">Done </w:t></w:r>
 <w:r><w:sym w:font="Wingdings" w:char="F0FC"/></w:r>
 <w:r><w:rPr><w:rFonts w:ascii="Wingdings" w:hAnsi="Wingdings"/></w:rPr><w:t>J</w:t></w:r>
 <w:r><w:sym w:font="Symbol" w:char="F061"/><w:sym w:font="Webdings" w:char="F061"/></w:r>
</w:p>"#;
    let d = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let p = paras(&d);
    // Stored as Word stores it…
    assert_eq!(p[0].plain_text(), "Done \u{F0FC}J\u{F061}\u{F061}");
    // …read (copied, exported as text) as the symbols shown.
    assert_eq!(p[0].shown_text(), "Done \u{2713}\u{263A}\u{3B1}\u{2714}");
    assert_eq!(d.shown_text(craft_wordmodel::StoryRef::Body), "Done \u{2713}\u{263A}\u{3B1}\u{2714}");
    // A round trip keeps the original characters and fonts.
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    let q = paras(&again);
    assert_eq!(q[0].plain_text(), p[0].plain_text());
    assert_eq!(q[0].shown_text(), p[0].shown_text());
}

/// The `w:sym` elements of a document's main part, as written.
fn sym_elements(bytes: &[u8]) -> Vec<String> {
    let parts = unzip(bytes);
    let xml = String::from_utf8_lossy(parts.get("word/document.xml").unwrap()).to_string();
    xml.match_indices("<w:sym ").map(|(i, _)| xml[i..].split("/>").next().unwrap().to_string() + "/>").collect()
}

#[test]
fn a_sym_character_keeps_its_symbol_font_when_the_text_font_changes() {
    // #2036: ECMA-376 §17.3.3.30 — a `w:sym` character's font is its own `w:font`, whatever the
    // run's font. Setting the whole paragraph in Times New Roman keeps the check mark.
    let body = r#"<w:p><w:r><w:t>a</w:t></w:r><w:r><w:sym w:font="Wingdings" w:char="F0FC"/></w:r><w:r><w:t>b</w:t></w:r></w:p>"#;
    let mut d = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let len = paras(&d)[0].text.len();
    d.format_range(&craft_wordmodel::Pos::body(0, 0), &craft_wordmodel::Pos::body(0, len), &|c| c.font = Some("Times New Roman".into())).unwrap();
    let p = paras(&d)[0];
    assert_eq!(p.plain_text(), "a\u{F0FC}b", "the stored character is unchanged");
    assert_eq!(p.props_of_char(1).font.as_deref(), Some("Times New Roman"), "the run font did change");
    assert_eq!(p.shown_text(), "a\u{2713}b");
    assert_eq!(d.shown_text(craft_wordmodel::StoryRef::Body), "a\u{2713}b");
    // Written back as a `w:sym` in its symbol font, so Word shows the symbol too.
    let bytes = craft_docx::write(&d).unwrap();
    assert_eq!(sym_elements(&bytes), vec![r#"<w:sym w:font="Wingdings" w:char="F0FC"/>"#.to_string()]);
    let again = craft_docx::read(&bytes).unwrap();
    let q = paras(&again)[0];
    assert_eq!(q.plain_text(), "a\u{F0FC}b");
    assert_eq!(q.shown_text(), "a\u{2713}b");
    assert_eq!(q.props_of_char(1).font.as_deref(), Some("Times New Roman"));
}

#[test]
fn a_sym_character_round_trips_as_w_sym() {
    let body = r#"<w:p><w:r><w:t xml:space="preserve">Done </w:t></w:r><w:r><w:sym w:font="Wingdings" w:char="F0FC"/><w:sym w:font="Symbol" w:char="F061"/></w:r></w:p>"#;
    let d = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let bytes = craft_docx::write(&d).unwrap();
    assert_eq!(
        sym_elements(&bytes),
        vec![r#"<w:sym w:font="Wingdings" w:char="F0FC"/>"#.to_string(), r#"<w:sym w:font="Symbol" w:char="F061"/>"#.to_string()]
    );
    let again = craft_docx::read(&bytes).unwrap();
    assert_eq!(paras(&again)[0].shown_text(), "Done \u{2713}\u{3B1}");
    assert_eq!(sym_elements(&craft_docx::write(&again).unwrap()), sym_elements(&bytes));
}

#[test]
fn hostile_sym_fonts_never_panic() {
    // Built in the model (an XML file couldn't even hold some of these names).
    let huge = "W".repeat(100_000);
    for font in ["", " ", "\u{1}", huge.as_str(), "Wingdings\u{FFFF}", "<&\"'>"] {
        let mut d = Document::from_text("a\u{F0FC}\u{1}\u{1F600}b");
        let len = paras(&d)[0].text.len();
        let f = font.to_string();
        d.format_range(&craft_wordmodel::Pos::body(0, 0), &craft_wordmodel::Pos::body(0, len), &|c| c.sym_font = Some(f.clone())).unwrap();
        let _ = d.shown_text(craft_wordmodel::StoryRef::Body);
        let bytes = craft_docx::write(&d).unwrap();
        let _ = craft_docx::read(&bytes).unwrap();
    }
}

#[test]
fn only_printable_characters_are_written_as_w_sym() {
    // `w:sym` holds a character code from U+0020 (the reader drops lower ones), like `w:t`.
    let mut d = Document::from_text("a\u{7}");
    d.format_range(&craft_wordmodel::Pos::body(0, 0), &craft_wordmodel::Pos::body(0, 2), &|c| c.sym_font = Some("Wingdings".into())).unwrap();
    assert_eq!(sym_elements(&craft_docx::write(&d).unwrap()), vec![r#"<w:sym w:font="Wingdings" w:char="0061"/>"#.to_string()]);
}

#[test]
fn pcl6_symbol_roundtrip() {
    let body = r#"<w:p><w:r><w:sym w:font="Symbol (PCL6)" w:char="F0B3"/></w:r></w:p>"#;
    let d = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    for doc in [&d, &again] {
        let p = paras(doc)[0];
        assert_eq!(p.text, "\u{F0B3}");
        assert_eq!(p.props_of_char(0).sym_font.as_deref(), Some("Symbol (PCL6)"));
        assert_eq!(p.shown_text(), "≥");
    }
}

#[test]
fn sym_hex_prefixes_and_break_type_casing() {
    let body = r##"
<w:p>
 <w:r><w:sym w:font="Wingdings" w:char="0xF0FC"/><w:sym w:font="Symbol" w:char="U+F061"/><w:sym w:font="Webdings" w:char="#xF061"/></w:r>
 <w:r><w:br w:type="Page"/><w:br w:type="Column"/><w:br w:type="textWrapping"/></w:r>
</w:p>"##;
    let d = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let p = paras(&d);
    assert_eq!(p[0].plain_text(), "\u{F0FC}\u{F061}\u{F061}\u{C}\u{E}\n");
}

#[test]
fn alternate_content_choice_and_fallback() {
    let body = r#"
<w:p><w:r><mc:AlternateContent>
  <mc:Choice Requires="wps"><w:drawing><wp:anchor behindDoc="0" distL="12700"><wp:positionH relativeFrom="page"><wp:posOffset>127000</wp:posOffset></wp:positionH><wp:positionV relativeFrom="paragraph"><wp:posOffset>0</wp:posOffset></wp:positionV><wp:extent cx="914400" cy="457200"/><wp:wrapSquare wrapText="bothSides"/><wp:docPr id="1" name="Text Box 1"/>
    <a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp><wps:cNvSpPr txBox="1"/><wps:spPr><a:prstGeom prst="rect"/></wps:spPr><wps:txbx><w:txbxContent><w:p><w:r><w:t>boxed</w:t></w:r></w:p></w:txbxContent></wps:txbx><wps:bodyPr/></wps:wsp></a:graphicData></a:graphic>
  </wp:anchor></w:drawing></mc:Choice>
  <mc:Fallback><w:pict><v:shape style="width:72pt;height:36pt"><v:textbox><w:txbxContent><w:p><w:r><w:t>old</w:t></w:r></w:p></w:txbxContent></v:textbox></v:shape></w:pict></mc:Fallback>
</mc:AlternateContent></w:r></w:p>
<w:p><mc:AlternateContent><mc:Choice Requires="w99"><w:r><w:t>future</w:t></w:r></mc:Choice><mc:Fallback><w:r><w:t>fallback text</w:t></w:r></mc:Fallback></mc:AlternateContent></w:p>"#;
    let d = read_body(body);
    let p = paras(&d);
    match &p[0].objects[0] {
        InlineObject::Shape { kind, w, h, float, story, .. } => {
            assert_eq!((*kind, *w, *h), (ShapeKind::TextBox, 72.0, 36.0));
            assert_eq!(float.wrap, Wrap::Square);
            assert_eq!(float.x, 10.0);
            assert_eq!(float.dist, 1.0);
            let s = d.parts.get(&story.unwrap()).unwrap();
            assert_eq!(s.blocks[0].as_para().unwrap().text, "boxed");
        }
        o => panic!("{o:?}"),
    }
    assert_eq!(p[1].text, "fallback text");
}

#[test]
fn table_look_bitmask_and_legacy_merges() {
    let body = r#"
<w:tbl>
 <w:tblPr><w:tblStyle w:val="TableGrid"/><w:tblW w:w="5000" w:type="pct"/><w:jc w:val="center"/><w:tblLook w:val="04A0"/></w:tblPr>
 <w:tblGrid><w:gridCol w:w="2000"/><w:gridCol w:w="2000"/><w:gridCol w:w="2000"/></w:tblGrid>
 <w:tr><w:tc><w:tcPr><w:hMerge w:val="restart"/></w:tcPr><w:p><w:r><w:t>wide</w:t></w:r></w:p></w:tc><w:tc><w:tcPr><w:hMerge/></w:tcPr><w:p/></w:tc><w:tc><w:tcPr><w:vMerge w:val="restart"/><w:shd w:val="clear" w:fill="FF0000"/></w:tcPr><w:p/></w:tc></w:tr>
 <w:tr><w:trPr><w:trHeight w:val="400"/></w:trPr><w:tc><w:tcPr><w:gridSpan w:val="2"/></w:tcPr><w:p/></w:tc><w:sdt><w:sdtContent><w:tc><w:tcPr><w:vMerge/></w:tcPr><w:p/></w:tc></w:sdtContent></w:sdt></w:tr>
</w:tbl>
<w:tbl><w:tblPr><w:tblLook w:firstRow="0" w:lastRow="1" w:firstColumn="1" w:lastColumn="0" w:noHBand="1" w:noVBand="0"/></w:tblPr><w:tr><w:tc><w:p/></w:tc></w:tr></w:tbl>
<w:p/>"#;
    let d = read_body(body);
    let Block::Table(t) = &*d.body[0] else { panic!() };
    assert_eq!(t.props.width_pct, Some(100.0));
    assert_eq!(t.props.align, Some(Align::Center));
    let l = t.props.look;
    assert!(l.header_row && l.first_column && l.banded_rows && !l.banded_columns && !l.total_row && !l.last_column);
    assert_eq!(t.rows[0].cells.len(), 2);
    assert_eq!(t.rows[0].cells[0].span(), 2);
    assert_eq!(t.rows[0].cells[1].props.vmerge, VMerge::Restart);
    assert_eq!(t.rows[1].cells[1].props.vmerge, VMerge::Continue);
    assert_eq!(t.rows[1].props.height, Some(20.0));
    assert_eq!(t.grid, vec![100.0, 100.0, 100.0]);
    let Block::Table(t2) = &*d.body[1] else { panic!() };
    let l = t2.props.look;
    assert!(!l.header_row && l.total_row && l.first_column && !l.last_column && !l.banded_rows && l.banded_columns);
}

#[test]
fn styles_numbering_settings_notes_comments_from_parts() {
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:asciiTheme="minorHAnsi" w:hAnsiTheme="minorHAnsi"/><w:sz w:val="22"/></w:rPr></w:rPrDefault><w:pPrDefault><w:pPr><w:spacing w:after="160" w:line="259" w:lineRule="auto"/></w:pPr></w:pPrDefault></w:docDefaults>
 <w:style w:type="paragraph" w:default="1" w:styleId="a"><w:name w:val="Normal"/><w:qFormat/></w:style>
 <w:style w:type="paragraph" w:styleId="1"><w:name w:val="heading 1"/><w:basedOn w:val="a"/><w:next w:val="a"/><w:uiPriority w:val="9"/><w:qFormat/><w:pPr><w:keepNext/><w:outlineLvl w:val="0"/></w:pPr><w:rPr><w:rFonts w:asciiTheme="majorHAnsi"/><w:b/><w:sz w:val="32"/></w:rPr></w:style>
 <w:style w:type="paragraph" w:customStyle="1" w:styleId="Fancy"><w:name w:val="Fancy"/><w:basedOn w:val="Fancy"/></w:style>
 <w:style w:type="table" w:styleId="Grid"><w:name w:val="Grid"/><w:tblPr><w:tblBorders><w:top w:val="single" w:sz="4"/></w:tblBorders></w:tblPr><w:tblStylePr w:type="firstRow"><w:rPr><w:b/></w:rPr><w:tcPr><w:shd w:val="clear" w:fill="4472C4"/></w:tcPr></w:tblStylePr></w:style>
</w:styles>"#
    );
    let theme = r#"<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="T"><a:themeElements><a:clrScheme name="T"><a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1><a:accent1><a:srgbClr val="4472C4"/></a:accent1></a:clrScheme><a:fontScheme name="T"><a:majorFont><a:latin typeface="Major Face"/></a:majorFont><a:minorFont><a:latin typeface="Minor Face"/></a:minorFont></a:fontScheme></a:themeElements></a:theme>"#;
    let numbering = format!(
        r#"<w:numbering {W_NS}><w:abstractNum w:abstractNumId="7"><w:name w:val="L"/><w:lvl w:ilvl="0"><w:start w:val="3"/><w:numFmt w:val="upperLetter"/><w:lvlText w:val="%1)"/><w:lvlJc w:val="right"/><w:pPr><w:ind w:left="720" w:hanging="360"/></w:pPr></w:lvl><w:lvl w:ilvl="1"><w:numFmt w:val="bullet"/><w:suff w:val="space"/><w:lvlText w:val="o"/><w:rPr><w:rFonts w:ascii="Courier New"/></w:rPr></w:lvl></w:abstractNum><w:num w:numId="2"><w:abstractNumId w:val="7"/><w:lvlOverride w:ilvl="0"><w:startOverride w:val="5"/></w:lvlOverride></w:num></w:numbering>"#
    );
    let settings = format!(
        r#"<w:settings {W_NS}><w:trackRevisions/><w:defaultTabStop w:val="708"/><w:evenAndOddHeaders w:val="1"/><w:footnotePr><w:pos w:val="sideways"/><w:numFmt w:val="lowerRoman"/><w:numStart w:val="-99999999999"/><w:numRestart w:val="eachPage"/></w:footnotePr></w:settings>"#
    );
    let footnotes = format!(
        r#"<w:footnotes {W_NS}><w:footnote w:type="separator" w:id="-1"><w:p><w:r><w:separator/></w:r></w:p></w:footnote><w:footnote w:id="1"><w:p><w:r><w:footnoteRef/></w:r><w:r><w:t xml:space="preserve"> Note text</w:t></w:r></w:p></w:footnote></w:footnotes>"#
    );
    let comments = format!(
        r#"<w:comments {W_NS}><w:comment w:id="5" w:author="Zed" w:initials="Z" w:date="2026-01-01T00:00:00Z"><w:p><w:r><w:annotationRef/></w:r><w:r><w:t>Look</w:t></w:r></w:p></w:comment></w:comments>"#
    );
    let header = format!(r#"<w:hdr {W_NS}><w:p><w:r><w:t>H</w:t></w:r></w:p></w:hdr>"#);
    let core = r#"<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:title>Doc Title</dc:title><cp:revision>3</cp:revision></cp:coreProperties>"#;
    let body = r#"
<w:p><w:pPr><w:pStyle w:val="1"/><w:numPr><w:ilvl w:val="1"/><w:numId w:val="2"/></w:numPr></w:pPr><w:commentRangeStart w:id="5"/><w:r><w:rPr><w:rFonts w:asciiTheme="majorHAnsi"/></w:rPr><w:t>Heading</w:t></w:r><w:r><w:footnoteReference w:id="1"/></w:r><w:r><w:commentReference w:id="5"/></w:r></w:p>
<w:p><w:pPr><w:pStyle w:val="a"/></w:pPr><w:ins w:id="1" w:author="I" w:date="2026-01-01T00:00:00Z"><w:r><w:t>new</w:t></w:r></w:ins><w:del w:id="2" w:author="I"><w:r><w:delText>old</w:delText></w:r></w:del></w:p>
<w:sectPr><w:headerReference w:type="default" r:id="rId9"/><w:pgSz w:w="16838" w:h="11906" w:orient="landscape"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="708" w:footer="708" w:gutter="0"/><w:cols w:space="708"/><w:titlePg w:val="0"/></w:sectPr>"#;
    let doc_rels = [
        ("rId1", "styles", "styles.xml"),
        ("rId2", "theme", "theme/theme1.xml"),
        ("rId3", "numbering", "numbering.xml"),
        ("rId4", "settings", "/word/settings.xml"),
        ("rId5", "footnotes", "footnotes.xml"),
        ("rId6", "comments", "comments.xml"),
        ("rId9", "header", "header1.xml"),
    ];
    let root_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/></Relationships>"#;
    let doc = format!(r#"<w:document {W_NS}><w:body>{body}</w:body></w:document>"#);
    let r = rels(&doc_rels);
    let bytes = zip(&[
        ("_rels/.rels", root_rels.as_bytes()),
        ("word/document.xml", doc.as_bytes()),
        ("word/_rels/document.xml.rels", r.as_bytes()),
        ("word/styles.xml", styles.as_bytes()),
        ("word/theme/theme1.xml", theme.as_bytes()),
        ("word/numbering.xml", numbering.as_bytes()),
        ("word/settings.xml", settings.as_bytes()),
        ("word/footnotes.xml", footnotes.as_bytes()),
        ("word/comments.xml", comments.as_bytes()),
        ("word/header1.xml", header.as_bytes()),
        ("docProps/core.xml", core.as_bytes()),
    ]);
    let d = craft_docx::read(&bytes).unwrap();
    assert_imported_styles(&d);
    assert_imported_numbering_and_settings(&d);
    assert_imported_body_and_metadata(&d);
}

fn assert_imported_styles(d: &Document) {
    // Styles: localized default id renamed to Normal; display names mapped.
    let h = d.styles.get("1").unwrap();
    assert_eq!(h.name, "Heading 1");
    assert_eq!(h.based_on.as_deref(), Some("Normal"));
    assert!(h.builtin && h.quick);
    assert_eq!(h.chr.font.as_deref(), Some("Major Face"));
    assert!(d.styles.get("Normal").is_some());
    assert_eq!(d.styles.get("Fancy").unwrap().based_on, None, "self-reference dropped");
    assert!(!d.styles.get("Fancy").unwrap().builtin);
    assert_eq!(d.styles.default_chr.font.as_deref(), Some("Minor Face"));
    assert_eq!(d.styles.default_chr.size, Some(11.0));
    let g = d.styles.get("Grid").unwrap().table.as_ref().unwrap();
    assert_eq!(g.header_fill, Some(craft_wordmodel::Rgb(0x44, 0x72, 0xC4)));
    assert_eq!(g.header_chr.bold, Some(true));
    assert_eq!(d.settings.theme_colors[4], craft_wordmodel::Rgb(0x44, 0x72, 0xC4));
    assert_eq!(d.settings.major_font, "Major Face");
}

fn assert_imported_numbering_and_settings(d: &Document) {
    // Numbering.
    let lv = d.numbering.level(2, 0).unwrap();
    assert_eq!((lv.start, lv.text.as_str(), lv.indent, lv.hanging, lv.align), (3, "%1)", 36.0, 18.0, Align::Right));
    let lv1 = d.numbering.level(2, 1).unwrap();
    assert_eq!(lv1.chr.font.as_deref(), Some("Courier New"));
    assert_eq!(lv1.suffix, craft_wordmodel::numbering::LevelSuffix::Space);
    assert_eq!(d.numbering.num(2).unwrap().start_overrides, vec![(0, 5)]);
    // Settings.
    assert!(d.settings.track_changes && d.settings.even_odd_headers);
    assert_eq!(d.settings.default_tab, 35.4);
    assert_eq!(d.settings.footnote_format, craft_wordmodel::section::NumFormat::LowerRoman);
    // A hostile start is clamped, an unknown position left out.
    let fp = d.settings.footnote_pr;
    assert_eq!((fp.pos, fp.num_start, fp.num_restart), (None, Some(1), Some(craft_wordmodel::section::NoteRestart::EachPage)));
}

fn assert_imported_body_and_metadata(d: &Document) {
    // Body.
    let p = paras(d);
    assert_eq!(p[0].props.style.as_deref(), Some("1"));
    assert_eq!(p[0].props.numbering, Some(craft_wordmodel::props::NumRef { num: 2, level: 1 }));
    assert_eq!(p[0].props_of_char(4).font.as_deref(), Some("Major Face"));
    match &p[0].objects[..] {
        [InlineObject::CommentStart { id: 5 }, InlineObject::NoteRef { kind: NoteKind::Footnote, id, .. }, InlineObject::CommentEnd { id: 5 }] => {
            let note = d.parts.get(id).unwrap().blocks[0].as_para().unwrap();
            assert_eq!(note.text, format!("{} Note text", craft_wordmodel::para::OBJ));
            assert_eq!(note.objects, vec![InlineObject::NoteRef { kind: NoteKind::Footnote, id: *id, custom: String::new() }]);
        }
        o => panic!("{o:?}"),
    }
    let c = d.comments.get(&5).unwrap();
    assert_eq!((c.author.as_str(), c.initials.as_str()), ("Zed", "Z"));
    assert_eq!(d.parts.get(&c.part).unwrap().blocks[0].as_para().unwrap().text, "Look");
    assert_eq!(p[1].props.style.as_deref(), Some("Normal"));
    assert_eq!(p[1].text, "newold");
    assert_eq!(d.revisions.len(), 2);
    assert_eq!(p[1].props_of_char(0).ins, Some(0));
    assert_eq!(p[1].props_of_char(3).del, Some(1));
    // Section + header.
    let s = &d.last_section;
    assert!(s.landscape);
    assert_eq!((s.page_w, s.page_h), (841.9, 595.3));
    assert!(!s.title_page);
    let hid = s.headers.default.unwrap();
    assert_eq!(d.parts.get(&hid).unwrap().blocks[0].as_para().unwrap().text, "H");
    assert_eq!(d.core.title, "Doc Title");
    assert_eq!(d.core.revision, 3);
}

/// A table style's own pPr/rPr, its `wholeTable` region (which covers every cell) and its table
/// shading and cell margins; a derived style keeps only what it sets itself.
#[test]
fn table_style_whole_table_shading_and_margins() {
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:style w:type="table" w:styleId="Base"><w:name w:val="Base"/><w:pPr><w:spacing w:after="0" w:line="240" w:lineRule="auto"/></w:pPr><w:tblPr><w:shd w:val="clear" w:color="auto" w:fill="EEEEEE"/><w:tblCellMar><w:top w:w="20" w:type="dxa"/><w:left w:w="288" w:type="dxa"/><w:bottom w:w="0" w:type="dxa"/><w:right w:w="288" w:type="dxa"/></w:tblCellMar></w:tblPr></w:style>
 <w:style w:type="table" w:styleId="Whole"><w:name w:val="Whole"/><w:basedOn w:val="Base"/><w:rPr><w:b/></w:rPr><w:tblStylePr w:type="wholeTable"><w:pPr><w:jc w:val="center"/></w:pPr><w:rPr><w:color w:val="1F4E79"/></w:rPr><w:tcPr><w:shd w:val="clear" w:color="auto" w:fill="DDEBF7"/></w:tcPr></w:tblStylePr><w:tblStylePr w:type="bogus"/><w:tblStylePr/></w:style>
</w:styles>"#
    );
    let bytes = docx("<w:p/>", &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)]);
    let d = craft_docx::read(&bytes).unwrap();
    let base = d.styles.get("Base").unwrap();
    let parts = base.table.as_ref().unwrap();
    assert_eq!(parts.fill, Some(craft_wordmodel::Rgb(0xEE, 0xEE, 0xEE)));
    assert_eq!(parts.cell_margins, Some([1.0, 14.4, 0.0, 14.4]));
    let whole = d.styles.get("Whole").unwrap();
    assert_eq!(whole.para.align, Some(Align::Center));
    assert_eq!(whole.chr.bold, Some(true));
    assert_eq!(whole.chr.color, Some(TextColor::Rgb(craft_wordmodel::Rgb(0x1F, 0x4E, 0x79))));
    assert_eq!(whole.table.as_ref().unwrap().fill, Some(craft_wordmodel::Rgb(0xDD, 0xEB, 0xF7)));
    assert_eq!(whole.table.as_ref().unwrap().cell_margins, None);
    let merged = d.styles.table_style("Whole").unwrap();
    assert_eq!(merged.para.space_after, Some(0.0), "from Base");
    assert_eq!(merged.para.align, Some(Align::Center));
    assert_eq!(merged.parts.fill, Some(craft_wordmodel::Rgb(0xDD, 0xEB, 0xF7)));
    assert_eq!(merged.parts.cell_margins, Some([1.0, 14.4, 0.0, 14.4]), "from Base");
}

fn gallery_ids(styles: &str) -> Vec<String> {
    let bytes = docx("<w:p/>", &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", styles)]);
    let d = craft_docx::read(&bytes).unwrap();
    d.styles.gallery().iter().map(|s| s.id.clone()).collect()
}

/// LibreOffice writes no `w:qFormat`: the Styles gallery still shows Word's usual quick styles.
#[test]
fn styles_without_qformat_get_the_default_gallery() {
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>
 <w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:basedOn w:val="Normal"/></w:style>
 <w:style w:type="paragraph" w:styleId="Heading2"><w:name w:val="heading 2"/><w:basedOn w:val="Normal"/></w:style>
 <w:style w:type="character" w:styleId="Emphasis"><w:name w:val="Emphasis"/></w:style>
</w:styles>"#
    );
    let ids = gallery_ids(&styles);
    for id in ["Normal", "NoSpacing", "Heading1", "Heading2", "Title", "Subtitle"] {
        assert!(ids.iter().any(|i| i == id), "{id} in {ids:?}");
    }
}

/// A custom style called "Title" is not the built-in one: it stays out of the gallery, and the
/// built-in Title is not added over its name.
#[test]
fn custom_style_named_like_a_quick_builtin_is_not_quick() {
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>
 <w:style w:type="paragraph" w:customStyle="1" w:styleId="MyTitle"><w:name w:val="Title"/></w:style>
</w:styles>"#
    );
    let ids = gallery_ids(&styles);
    assert!(ids.iter().any(|i| i == "Normal"), "{ids:?}");
    assert!(!ids.iter().any(|i| i == "MyTitle" || i == "Title"), "{ids:?}");
}

/// A file that uses `w:qFormat` (Word's own) keeps exactly the gallery it says.
#[test]
fn styles_with_qformat_keep_their_gallery() {
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/></w:style>
 <w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:basedOn w:val="Normal"/></w:style>
</w:styles>"#
    );
    assert_eq!(gallery_ids(&styles), vec!["Normal".to_string()]);
}

/// Word starts every note with a `w:footnoteRef` / `w:endnoteRef` mark: the note's own number.
/// It reads as a reference to the note itself, so the note text shows its number.
#[test]
fn note_marks_reference_their_own_note() {
    let note = |tag: &str, mark: &str, style: &str, id: u32, text: &str| {
        format!(
            r#"<w:{tag} w:id="{id}"><w:p><w:pPr><w:pStyle w:val="{style}Text"/></w:pPr><w:r><w:rPr><w:rStyle w:val="{style}Reference"/></w:rPr><w:{mark}/></w:r><w:r><w:t xml:space="preserve"> {text}</w:t></w:r></w:p></w:{tag}>"#
        )
    };
    let sep = |tag: &str| {
        format!(
            r#"<w:{tag} w:type="separator" w:id="-1"><w:p><w:r><w:separator/></w:r></w:p></w:{tag}><w:{tag} w:type="continuationSeparator" w:id="0"><w:p><w:r><w:continuationSeparator/></w:r></w:p></w:{tag}>"#
        )
    };
    // The second footnote has a stray endnote mark, which is not its number.
    let footnotes = format!(
        r#"<w:footnotes {W_NS}>{}{}<w:footnote w:id="2"><w:p><w:r><w:endnoteRef/><w:t>Stray</w:t></w:r></w:p></w:footnote>{}</w:footnotes>"#,
        sep("footnote"),
        note("footnote", "footnoteRef", "Footnote", 1, "First."),
        note("footnote", "footnoteRef", "Footnote", 3, "Third."),
    );
    let endnotes = format!(r#"<w:endnotes {W_NS}>{}{}</w:endnotes>"#, sep("endnote"), note("endnote", "endnoteRef", "Endnote", 1, "End."));
    // A mark outside a note (here in the body) refers to nothing.
    let body = r#"<w:p><w:r><w:footnoteRef/><w:t>A</w:t></w:r><w:r><w:footnoteReference w:id="1"/></w:r><w:r><w:footnoteReference w:id="2"/></w:r><w:r><w:footnoteReference w:id="3"/></w:r><w:r><w:endnoteReference w:id="1"/></w:r></w:p>"#;
    let bytes = docx(
        body,
        &[("rId1", "footnotes", "footnotes.xml"), ("rId2", "endnotes", "endnotes.xml")],
        &[("word/footnotes.xml", &footnotes), ("word/endnotes.xml", &endnotes)],
    );
    let d = craft_docx::read(&bytes).unwrap();
    let p = paras(&d)[0];
    assert_eq!(p.text.chars().filter(|c| *c == craft_wordmodel::para::OBJ).count(), 4, "{:?}", p.objects);
    let refs: Vec<(NoteKind, u32)> = p
        .objects
        .iter()
        .map(|o| match o {
            InlineObject::NoteRef { kind, id, .. } => (*kind, *id),
            o => panic!("{o:?}"),
        })
        .collect();
    let first_para = |id: u32| d.parts.get(&id).unwrap().blocks[0].as_para().unwrap();
    for (kind, id) in [refs[0], refs[2], refs[3]] {
        let n = first_para(id);
        assert_eq!(n.objects, vec![InlineObject::NoteRef { kind, id, custom: String::new() }], "note {id}");
        assert!(n.text.starts_with(craft_wordmodel::para::OBJ), "{:?}", n.text);
        let style = if kind == NoteKind::Footnote { "FootnoteReference" } else { "EndnoteReference" };
        assert_eq!(n.props_of_char(0).style.as_deref(), Some(style));
    }
    assert_eq!(first_para(refs[0].1).plain_text(), " First.");
    assert_eq!(first_para(refs[3].1).plain_text(), " End.");
    let stray = first_para(refs[1].1);
    assert!(stray.objects.is_empty(), "{:?}", stray.objects);
    assert_eq!(stray.text, "Stray");
}

#[test]
fn empty_tbl_borders_elements_leave_sides_unset() {
    // Style TS: single borders on all six sides. Document: table styled TS with an empty
    // paired <w:tblBorders></w:tblBorders> and empty <w:tcBorders></w:tcBorders> per cell.
    // (Hand-written from ECMA-376 §17.4.39/§17.4.43; do not use files produced by Word.)
    let styles = format!(
        r#"<w:styles {W_NS}><w:style w:type="table" w:styleId="TS"><w:name w:val="TS"/><w:tblPr><w:tblBorders><w:top w:val="single" w:sz="2" w:color="000000"/><w:left w:val="single" w:sz="2" w:color="000000"/><w:bottom w:val="single" w:sz="2" w:color="000000"/><w:right w:val="single" w:sz="2" w:color="000000"/><w:insideH w:val="single" w:sz="2" w:color="000000"/><w:insideV w:val="single" w:sz="2" w:color="000000"/></w:tblBorders></w:tblPr></w:style></w:styles>"#
    );
    let body = r#"<w:tbl><w:tblPr><w:tblStyle w:val="TS"/><w:tblBorders></w:tblBorders></w:tblPr><w:tblGrid><w:gridCol w:w="4000"/><w:gridCol w:w="4000"/></w:tblGrid><w:tr><w:tc><w:tcPr><w:tcBorders></w:tcBorders></w:tcPr><w:p/></w:tc><w:tc><w:tcPr><w:tcBorders></w:tcBorders></w:tcPr><w:p/></w:tc></w:tr></w:tbl>"#;
    let d = craft_docx::read(&docx(body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    let t = d.body.iter().find_map(|b| b.as_table()).unwrap();
    assert_eq!(t.props.borders, Some(craft_wordmodel::props::Borders::default()));
    assert_eq!(t.rows[0].cells[0].props.borders, Some(craft_wordmodel::props::Borders::default()));
    let parts = d.styles.get("TS").unwrap().table.clone().unwrap();
    let b = parts.borders.unwrap();
    assert!(b.top.is_some() && b.between.is_some() && b.inside_v.is_some());
}

/// A style ID defined twice is its last definition, whole (Word drops the earlier one rather
/// than merging: observed with synthetic documents). Generators that write a placeholder
/// Heading 1 and then their own made headings come out in the placeholder's font and size.
#[test]
fn a_style_defined_twice_is_its_last_definition() {
    let styles = format!(
        r#"<w:styles {W_NS}>
<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:pPr><w:jc w:val="center"/></w:pPr><w:rPr><w:i/><w:color w:val="FF0000"/><w:sz w:val="40"/></w:rPr></w:style>
<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:rPr><w:b/><w:color w:val="0000FF"/><w:sz w:val="24"/></w:rPr></w:style>
</w:styles>"#
    );
    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>Probe</w:t></w:r></w:p>"#;
    let d = craft_docx::read(&docx(body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    assert_eq!(d.styles.styles.iter().filter(|s| s.id == "Heading1").count(), 1);
    let h = d.styles.get("Heading1").unwrap();
    assert_eq!((h.chr.bold, h.chr.italic, h.chr.size), (Some(true), None, Some(12.0)));
    assert_eq!(h.chr.color, Some(TextColor::Rgb(Rgb(0, 0, 0xFF))));
    assert_eq!(h.para.align, None, "nothing kept from the first definition");
}

/// #3889: Word in another language writes the TOC styles under ids in that language (`toc 1` is
/// `Sumrio1` in Portuguese). They take the engine's ids, which Update Table and the writer know
/// the entries by, with their formatting and references; an id the file already uses stays.
#[test]
fn localized_toc_style_ids_take_the_engine_ids() {
    let styles = format!(
        r#"<w:styles {W_NS}>
<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>
<w:style w:type="paragraph" w:styleId="CabealhodoSumrio"><w:name w:val="TOC Heading"/><w:next w:val="Normal"/></w:style>
<w:style w:type="paragraph" w:styleId="Sumrio1"><w:name w:val="toc 1"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:pPr><w:spacing w:after="100"/></w:pPr></w:style>
<w:style w:type="paragraph" w:styleId="Sumrio2"><w:name w:val="toc 2"/><w:basedOn w:val="Sumrio1"/><w:pPr><w:ind w:left="220"/></w:pPr></w:style>
<w:style w:type="paragraph" w:styleId="TOC3"><w:name w:val="toc 3"/></w:style>
<w:style w:type="paragraph" w:styleId="Sumrio3"><w:name w:val="toc 3"/></w:style>
</w:styles>"#
    );
    let p = |st: &str| format!(r#"<w:p><w:pPr><w:pStyle w:val="{st}"/></w:pPr><w:r><w:t>{st}</w:t></w:r></w:p>"#);
    let body = ["CabealhodoSumrio", "Sumrio1", "Sumrio2", "Sumrio3"].map(p).concat();
    let d = craft_docx::read(&docx(&body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    let ids: Vec<Option<&str>> = paras(&d).iter().map(|p| p.props.style.as_deref()).collect();
    assert_eq!(ids, [Some("TOCHeading"), Some("TOC1"), Some("TOC2"), Some("Sumrio3")]);
    let toc2 = d.styles.get("TOC2").unwrap();
    assert_eq!((toc2.name.as_str(), toc2.based_on.as_deref(), toc2.para.indent_left), ("TOC 2", Some("TOC1"), Some(11.0)));
    assert_eq!(d.styles.get("TOC1").unwrap().para.space_after, Some(5.0));
    assert!(d.styles.get("Sumrio1").is_none() && d.styles.get("TOC3").is_some() && d.styles.get("Sumrio3").is_some());
}

#[test]
fn vml_image_and_inline_drawing() {
    let png: &[u8] = b"\x89PNG\r\n\x1a\nnot really a png";
    let body = r#"
<w:p><w:r><w:pict><v:shape style="width:1in;height:36pt" alt="vml pic"><v:imagedata r:id="rIdImg" o:title="t"/></v:shape></w:pict></w:r>
<w:r><w:drawing><wp:inline><wp:extent cx="1270000" cy="635000"/><wp:docPr id="3" name="P" descr="alt text"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rIdImg"/><a:srcRect l="10000"/></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>
<w:r><w:drawing><wp:inline><wp:extent cx="1" cy="1"/><a:graphic><a:graphicData><pic:pic><pic:blipFill><a:blip r:embed="rIdMissing"/></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>"#;
    let doc = format!(r#"<w:document {W_NS}><w:body>{body}</w:body></w:document>"#);
    let r = rels(&[("rIdImg", "image", "media/pic.png"), ("rIdMissing", "image", "media/nope.png")]);
    let bytes = zip(&[
        ("_rels/.rels", ROOT_RELS.as_bytes()),
        ("word/document.xml", doc.as_bytes()),
        ("word/_rels/document.xml.rels", r.as_bytes()),
        ("word/media/pic.png", png),
    ]);
    let d = craft_docx::read(&bytes).unwrap();
    let p = paras(&d);
    assert_eq!(p[0].objects.len(), 2);
    match (&p[0].objects[0], &p[0].objects[1]) {
        (InlineObject::Image { media: m1, w: w1, h: h1, alt: a1, .. }, InlineObject::Image { media: m2, w: w2, h: h2, alt: a2, crop, .. }) => {
            assert_eq!((m1.as_str(), *w1, *h1, a1.as_str()), ("pic.png", 72.0, 36.0, "vml pic"));
            assert_eq!((m2.as_str(), *w2, *h2, a2.as_str()), ("pic.png", 100.0, 50.0, "alt text"));
            assert_eq!(crop[0], 0.1);
        }
        o => panic!("{o:?}"),
    }
    assert_eq!(d.media.get("pic.png").unwrap().as_slice(), png);
}

#[test]
fn chart_and_diagram_drawings_are_graphic_objects() {
    // A diagram's data holds a blip: the URI decides first, so no picture is read from it.
    let drawing = |uri: &str, data: &str| {
        format!(
            r#"<w:r><w:drawing><wp:inline><wp:extent cx="2743200" cy="1828800"/><wp:docPr id="5" name="G" descr="sales"/><a:graphic><a:graphicData uri="{uri}">{data}</a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#
        )
    };
    let body = format!(
        "<w:p>{}{}</w:p>",
        drawing("http://schemas.openxmlformats.org/drawingml/2006/chart", ""),
        drawing("http://schemas.openxmlformats.org/drawingml/2006/diagram", r#"<a:blip r:embed="rIdImg"/>"#)
    );
    let d = read_body(&body);
    let p = paras(&d);
    assert_eq!(p[0].objects.len(), 2);
    match (&p[0].objects[0], &p[0].objects[1]) {
        (InlineObject::Graphic { w: w1, h: h1, alt, graphic: g1, .. }, InlineObject::Graphic { graphic: g2, .. }) => {
            assert_eq!((*w1, *h1, alt.as_str()), (216.0, 144.0, "sales"));
            assert_eq!(g1.kind, craft_wordmodel::graphic::GraphicKind::Chart);
            assert_eq!(g2.kind, craft_wordmodel::graphic::GraphicKind::Diagram);
            assert!(g1.items.is_empty() && g2.items.is_empty());
        }
        o => panic!("{o:?}"),
    }
}

/// A text box shape's style text colour (`wps:style/a:fontRef`) is kept on its story, as what
/// automatic text colour means inside it; a box without one has none.
#[test]
fn a_text_box_s_style_font_colour_is_read() {
    let shape = |style: &str| {
        format!(
            r#"<w:r><w:drawing><wp:anchor behindDoc="0"><wp:positionH relativeFrom="column"><wp:posOffset>0</wp:posOffset></wp:positionH><wp:positionV relativeFrom="paragraph"><wp:posOffset>0</wp:posOffset></wp:positionV><wp:extent cx="1270000" cy="635000"/><wp:wrapNone/><wp:docPr id="1" name="S"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp><wps:spPr><a:prstGeom prst="rect"/></wps:spPr>{style}<wps:txbx><w:txbxContent><w:p><w:r><w:t>In the box</w:t></w:r></w:p></w:txbxContent></wps:txbx><wps:bodyPr/></wps:wsp></a:graphicData></a:graphic></wp:anchor></w:drawing></w:r>"#
        )
    };
    let style = r#"<wps:style><a:lnRef idx="2"><a:srgbClr val="000000"/></a:lnRef><a:fillRef idx="1"><a:srgbClr val="203040"/></a:fillRef><a:effectRef idx="0"><a:srgbClr val="000000"/></a:effectRef><a:fontRef idx="minor"><a:srgbClr val="FFFFFF"/></a:fontRef></wps:style>"#;
    let d = read_body(&format!("<w:p>{}{}</w:p>", shape(style), shape("")));
    let boxes: Vec<_> =
        paras(&d)[0].objects.iter().filter_map(|o| if let InlineObject::Shape { story: Some(id), .. } = o { Some(*id) } else { None }).collect();
    let [styled, plain] = boxes.as_slice() else { panic!("{boxes:?}") };
    assert_eq!(d.parts[styled].body.auto_color, Some(Rgb(0xFF, 0xFF, 0xFF)));
    assert_eq!(d.parts[plain].body.auto_color, None);
}

#[test]
fn a_chart_part_is_built_once_and_only_through_a_chart_relationship() {
    let chart = r#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart><c:plotArea><c:barChart><c:ser><c:val><c:numLit><c:ptCount val="2"/><c:pt idx="0"><c:v>1</c:v></c:pt><c:pt idx="1"><c:v>2</c:v></c:pt></c:numLit></c:val></c:ser></c:barChart></c:plotArea></c:chart></c:chartSpace>"#;
    let drawing = |id: &str| {
        format!(
            r#"<w:r><w:drawing><wp:inline><wp:extent cx="2743200" cy="1828800"/><wp:docPr id="5" name="G"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" r:id="{id}"/></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#
        )
    };
    let body = format!("<w:p>{}{}{}</w:p>", drawing("rIdChart"), drawing("rIdChart"), drawing("rIdNotChart"));
    let bytes = docx(
        &body,
        &[("rIdChart", "chart", "charts/chart1.xml"), ("rIdNotChart", "image", "charts/chart1.xml")],
        &[("word/charts/chart1.xml", chart)],
    );
    let d = craft_docx::read(&bytes).unwrap();
    let graphics: Vec<_> = paras(&d)[0]
        .objects
        .iter()
        .filter_map(|o| if let InlineObject::Graphic { graphic, .. } = o { Some(graphic.clone()) } else { None })
        .collect();
    assert_eq!(graphics.len(), 3);
    assert!(!graphics[0].items.is_empty(), "the chart is drawn");
    assert!(std::sync::Arc::ptr_eq(&graphics[0], &graphics[1]), "one build for both references");
    assert!(graphics[2].items.is_empty(), "an image relationship is not a chart");
}

#[test]
fn strict_namespace_and_bad_numbers() {
    let doc = r#"<w:document xmlns:w="http://purl.oclc.org/ooxml/wordprocessingml/main"><w:body>
<w:p><w:pPr><w:jc w:val="end"/><w:ind w:start="1in" w:hanging="abc"/><w:spacing w:before="-50" w:line="99999999999999999999" w:lineRule="exact"/><w:outlineLvl w:val="300"/><w:numPr><w:numId w:val="-4"/></w:numPr></w:pPr>
<w:r><w:rPr><w:sz w:val="NaN"/><w:w w:val="999999"/><w:position w:val="-1e30"/><w:color w:val="GGGGGG"/><w:highlight w:val="mauve"/><w:u w:val="squiggle"/></w:rPr><w:t>strict</w:t></w:r></w:p>
<w:tbl><w:tblGrid><w:gridCol w:w="-5"/></w:tblGrid><w:tr><w:tc><w:tcPr><w:gridSpan w:val="99999"/></w:tcPr><w:p/></w:tc></w:tr></w:tbl>
<w:sectPr><w:pgSz w:w="0" w:h="x"/><w:cols w:num="-3"/><w:pgNumType w:start="-1" w:fmt="klingon"/></w:sectPr>
</w:body></w:document>"#;
    let bytes = zip(&[("_rels/.rels", ROOT_RELS.as_bytes()), ("word/document.xml", doc.as_bytes())]);
    let d = craft_docx::read(&bytes).unwrap();
    let p = paras(&d);
    assert_eq!(p[0].text, "strict");
    assert_eq!(p[0].props.align, Some(Align::Right));
    assert_eq!(p[0].props.indent_left, Some(72.0));
    assert_eq!(p[0].props.space_before, Some(0.0));
    assert_eq!(p[0].props.outline_level, Some(9));
    let c = p[0].props_of_char(0);
    assert_eq!(c.size, None);
    assert_eq!(c.scale, Some(600.0));
    assert_eq!(c.color, None);
    let Block::Table(t) = &*d.body[1] else { panic!() };
    assert_eq!(t.rows[0].cells[0].span(), 63);
    assert_eq!(d.last_section.page_w, 612.0);
    assert_eq!(d.last_section.columns.count, 1);
    // The document can be written back.
    craft_docx::write(&d).unwrap();
}

#[test]
fn unbalanced_fields_and_markers() {
    let body = r#"
<w:p><w:r><w:fldChar w:fldCharType="end"/></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:t>a</w:t></w:r><w:bookmarkEnd w:id="77"/><w:commentRangeEnd w:id="3"/></w:p>
<w:p><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText>IF </w:instrText></w:r><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText>MERGEFIELD x</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:t>X</w:t></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r><w:r><w:instrText> = "y"</w:instrText></w:r></w:p>
<w:bookmarkStart w:id="1" w:name="between"/>
<w:p><w:r><w:t>after</w:t></w:r></w:p>
<w:bookmarkEnd w:id="1"/>"#;
    let d = read_body(body);
    let p = paras(&d);
    assert_eq!(p[0].text, "a");
    assert_eq!(
        p[1].objects,
        vec![InlineObject::Field {
            instr: "IF X = \"y\"".into(),
            result: String::new(),
            locked: false,
            dirty: false,
            code: false,
            form: String::new()
        }]
    );
    assert_eq!(p[2].objects, vec![InlineObject::BookmarkStart { name: "between".into() }, InlineObject::BookmarkEnd { name: "between".into() }]);
    assert_eq!(p[2].plain_text(), "after");
}

#[test]
fn field_code_spans_paragraphs() {
    let body = r#"
<w:p><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText>IF</w:instrText></w:r></w:p>
<w:p><w:r><w:instrText> MERGEFIELD x</w:instrText><w:br/><w:instrText> = "y"</w:instrText></w:r></w:p>
<w:p><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r></w:p>
<w:p><w:r><w:t>Visible</w:t></w:r></w:p>"#;
    let doc = read_body(body);
    let p = paras(&doc);
    assert_eq!(p.len(), 4);
    for code in &p[..2] {
        assert!(code.plain_text().is_empty());
        assert_eq!(code.mark.hidden, Some(true));
    }
    assert_eq!(p[2].mark.hidden, None);
    assert_eq!(p[3].plain_text(), "Visible");
    assert_eq!(p[3].mark.hidden, None);
}

#[test]
fn empty_field_results_keep_line() {
    let body = r#"<w:p><w:r><w:fldChar w:fldCharType="begin"/><w:instrText>PAGE</w:instrText><w:fldChar w:fldCharType="separate"/><w:fldChar w:fldCharType="end"/></w:r></w:p>
<w:p><w:r><w:fldChar w:fldCharType="begin"/><w:instrText>IF</w:instrText></w:r></w:p>
<w:p/>
<w:p><w:r><w:instrText> x = y</w:instrText><w:fldChar w:fldCharType="separate"/><w:t>Result</w:t><w:fldChar w:fldCharType="end"/></w:r></w:p>"#;
    let doc = read_body(body);
    let p = paras(&doc);
    assert_eq!(p[0].mark.hidden, None);
    assert!(matches!(&p[0].objects[0], InlineObject::Field { instr, .. } if instr == "PAGE"));
    assert_eq!(p[1].mark.hidden, Some(true));
    assert_eq!(p[2].mark.hidden, Some(true));
    assert_eq!(p[3].mark.hidden, None);
    assert_eq!(p[3].plain_text(), "Result");
}

#[test]
fn header_self_reference_and_escaping_targets() {
    let hdr = format!(
        r#"<w:hdr {W_NS}><w:p><w:pPr><w:sectPr><w:headerReference w:type="default" r:id="rId1"/></w:sectPr></w:pPr><w:r><w:t>loop</w:t></w:r></w:p></w:hdr>"#
    );
    let hdr_rels = rels(&[("rId1", "header", "header1.xml")]);
    let body = r#"<w:p><w:r><w:drawing><wp:inline><a:graphic><a:graphicData><pic:pic><pic:blipFill><a:blip r:embed="rIdEvil"/></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/><w:headerReference w:type="even" r:id="rIdH"/><w:footerReference w:type="first" r:id="rIdNone"/></w:sectPr>"#;
    let doc = format!(r#"<w:document {W_NS}><w:body>{body}</w:body></w:document>"#);
    let r = rels(&[("rIdH", "header", "header1.xml"), ("rIdEvil", "image", "../../../../etc/passwd"), ("rIdNone", "footer", "missing.xml")]);
    let bytes = zip(&[
        ("_rels/.rels", ROOT_RELS.as_bytes()),
        ("word/document.xml", doc.as_bytes()),
        ("word/_rels/document.xml.rels", r.as_bytes()),
        ("word/header1.xml", hdr.as_bytes()),
        ("word/_rels/header1.xml.rels", hdr_rels.as_bytes()),
    ]);
    let d = craft_docx::read(&bytes).unwrap();
    assert_eq!(d.last_section.headers.default, d.last_section.headers.even);
    assert!(d.media.is_empty());
    let out = craft_docx::write(&d).unwrap();
    craft_docx::read(&out).unwrap();
}

/// A document whose settings part is `settings` (None: no settings part at all).
fn with_settings(settings: Option<&str>) -> Document {
    let body = "<w:p><w:r><w:t>x</w:t></w:r></w:p>";
    match settings {
        None => read_body(body),
        Some(inner) => {
            let s = format!(r#"<w:settings {W_NS}>{inner}</w:settings>"#);
            craft_docx::read(&docx(body, &[("rId1", "settings", "settings.xml")], &[("word/settings.xml", &s)])).unwrap()
        }
    }
}

#[test]
fn table_contextual_spacing_compatibility_flag_is_read() {
    assert!(!with_settings(None).settings.allow_space_of_same_style_in_table);
    for (flag, expected) in [
        ("", false),
        (r#"<w:allowSpaceOfSameStyleInTable w:val="0"/>"#, false),
        (r#"<w:allowSpaceOfSameStyleInTable/>"#, true),
        (r#"<w:allowSpaceOfSameStyleInTable w:val="1"/>"#, true),
    ] {
        let settings = format!("<w:compat>{flag}</w:compat>");
        assert_eq!(with_settings(Some(&settings)).settings.allow_space_of_same_style_in_table, expected, "{flag}");
    }
}

#[test]
fn compatibility_mode_is_read_and_defaults_to_word_2007() {
    let compat = |v: &str| {
        format!(r#"<w:compat><w:compatSetting w:name="compatibilityMode" w:uri="http://schemas.microsoft.com/office/word" w:val="{v}"/></w:compat>"#)
    };
    assert_eq!(with_settings(Some(&compat("15"))).settings.compat_mode, 15);
    assert_eq!(with_settings(Some(&compat("14"))).settings.compat_mode, 14);
    // Unnamed, out of range or junk values.
    assert_eq!(with_settings(Some("<w:compat/>")).settings.compat_mode, craft_wordmodel::LEGACY_COMPAT_MODE);
    assert_eq!(with_settings(None).settings.compat_mode, craft_wordmodel::LEGACY_COMPAT_MODE);
    assert_eq!(with_settings(Some(&compat("-3"))).settings.compat_mode, 11);
    assert_eq!(with_settings(Some(&compat("99999"))).settings.compat_mode, 99);
    assert_eq!(with_settings(Some(&compat("abc"))).settings.compat_mode, craft_wordmodel::LEGACY_COMPAT_MODE);
    // Another vendor's setting of the same name is ignored.
    let other = r#"<w:compat><w:compatSetting w:name="compatibilityMode" w:uri="urn:example" w:val="15"/></w:compat>"#;
    assert_eq!(with_settings(Some(other)).settings.compat_mode, craft_wordmodel::LEGACY_COMPAT_MODE);
}

#[test]
fn line_rule_is_read_case_insensitively() {
    // Word accepts `atleast` as well as the spec's `atLeast`.
    let d = read_body(
        r#"<w:p><w:pPr><w:spacing w:line="280" w:lineRule="atleast"/></w:pPr><w:r><w:t>x</w:t></w:r></w:p><w:p><w:pPr><w:spacing w:line="300" w:lineRule="EXACT"/></w:pPr></w:p>"#,
    );
    let p = paras(&d);
    assert_eq!(p[0].props.line_spacing, Some(craft_wordmodel::props::LineSpacing::AtLeast(14.0)));
    assert_eq!(p[1].props.line_spacing, Some(craft_wordmodel::props::LineSpacing::Exactly(15.0)));
}

/// #2329: Word 2024 saves strict OOXML with the line height written out with a unit
/// (`w:line="13.90pt"`). Under `auto` it reads through twips, as Word renders it (13.90 × 20 =
/// 278; the 1.1583 multiple), not as 240ths of a line like the bare number — a Word file with
/// a `line="13.90pt"` default came in at 13.9 lines per line of text.
#[test]
fn strict_line_heights_with_a_unit_are_read_as_point_multiples() {
    let d = read_body(
        r#"<w:p><w:pPr><w:spacing w:after="8pt" w:line="13.90pt" w:lineRule="auto"/></w:pPr><w:r><w:t>x</w:t></w:r></w:p><w:p><w:pPr><w:spacing w:line="13.90pt" w:lineRule="exact"/></w:pPr></w:p>"#,
    );
    let p = paras(&d);
    let Some(craft_wordmodel::props::LineSpacing::Multiple(m)) = p[0].props.line_spacing else {
        panic!("auto line spacing: {:?}", p[0].props.line_spacing)
    };
    assert!((m - 278.0 / 240.0).abs() < 1e-5, "{m}");
    assert_eq!(p[0].props.space_after, Some(8.0), "the unit form of w:after too");
    assert_eq!(p[1].props.line_spacing, Some(craft_wordmodel::props::LineSpacing::Exactly(13.9)), "exact keeps reading it as points");
    // Saves as the transitional 240ths form and reads back the same multiple.
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    let Some(craft_wordmodel::props::LineSpacing::Multiple(m2)) = paras(&again)[0].props.line_spacing else { panic!("multiple after a save") };
    assert!((m2 - m).abs() < 1e-5, "{m2} vs {m}");
}

#[test]
fn char_border_reads_and_nil_resolves_off() {
    let d = read_body(
        r#"<w:p><w:r><w:rPr><w:bdr w:val="single" w:sz="8" w:space="1" w:color="FF0000"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:bdr w:val="nil"/></w:rPr><w:t>b</w:t></w:r></w:p>"#,
    );
    let p = paras(&d)[0];
    assert_eq!(p.props_of_char(0).border, Some(Border { style: BorderStyle::Single, width: 1.0, color: Some(Rgb(0xFF, 0, 0)), space: 1.0 }));
    let nil = p.props_of_char(1);
    assert_eq!(nil.border.map(|b| b.style), Some(BorderStyle::None));
    assert_eq!(d.styles.resolve_char(None, nil).border, None);
}

#[test]
fn anchor_alignment_reference_areas_and_distances() {
    let shape = |pos: &str, dist: &str| {
        format!(
            r#"<w:r><w:drawing><wp:anchor behindDoc="0" {dist}>{pos}<wp:extent cx="127000" cy="127000"/><wp:wrapTopAndBottom/><wp:docPr id="1" name="S"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp><wps:spPr><a:prstGeom prst="ellipse"/></wps:spPr></wps:wsp></a:graphicData></a:graphic></wp:anchor></w:drawing></w:r>"#
        )
    };
    let body = format!(
        "<w:p>{}{}</w:p>",
        shape(
            r#"<wp:positionH relativeFrom="margin"><wp:align>center</wp:align></wp:positionH><wp:positionV relativeFrom="topMargin"><wp:posOffset>-12700</wp:posOffset></wp:positionV>"#,
            r#"distT="25400" distB="50800" distL="0" distR="114300""#
        ),
        shape(
            r#"<wp:positionH relativeFrom="leftMargin"><wp:posOffset>63500</wp:posOffset></wp:positionH><wp:positionV relativeFrom="line"><wp:align>bottom</wp:align></wp:positionV>"#,
            ""
        ),
    );
    let d = read_body(&body);
    let p = paras(&d);
    let floats: Vec<_> =
        p[0].objects.iter().filter_map(|o| if let InlineObject::Shape { float, .. } = o { Some(float.clone()) } else { None }).collect();
    let [a, b] = floats.as_slice() else { panic!("{floats:?}") };
    assert_eq!((a.h_rel, a.h_align, a.v_rel, a.v_align, a.y), (Anchor::Margin, Some(FloatAlign::Center), Anchor::TopMargin, None, -1.0));
    assert_eq!((a.dist, a.dist_top, a.dist_bottom), (9.0, 2.0, 4.0));
    assert_eq!((b.h_rel, b.h_align, b.x, b.v_rel, b.v_align), (Anchor::LeftMargin, None, 5.0, Anchor::Line, Some(FloatAlign::End)));
    assert_eq!((b.dist, b.dist_top, b.dist_bottom), (0.0, 0.0, 0.0));
}

#[test]
fn anchor_stacking_order_is_read_and_kept() {
    let shape = |z: &str| {
        format!(
            r#"<w:r><w:drawing><wp:anchor behindDoc="0" {z}><wp:positionH relativeFrom="column"><wp:posOffset>0</wp:posOffset></wp:positionH><wp:positionV relativeFrom="paragraph"><wp:posOffset>0</wp:posOffset></wp:positionV><wp:extent cx="127000" cy="127000"/><wp:wrapNone/><wp:docPr id="1" name="S"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp><wps:spPr><a:prstGeom prst="rect"/></wps:spPr></wps:wsp></a:graphicData></a:graphic></wp:anchor></w:drawing></w:r>"#
        )
    };
    let body = format!("<w:p>{}{}{}</w:p>", shape(r#"relativeHeight="251660288""#), shape(r#"relativeHeight="251657214""#), shape(""));
    let zs = |d: &Document| -> Vec<u32> {
        paras(d)[0].objects.iter().filter_map(|o| if let InlineObject::Shape { float, .. } = o { Some(float.z) } else { None }).collect()
    };
    let d = read_body(&body);
    assert_eq!(zs(&d), [251660288, 251657214, 0]);
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    let z = zs(&again);
    assert_eq!(&z[..2], &[251660288, 251657214]);
    assert!(z[2] > 0, "an object without one gets an order on saving: {z:?}");
}

#[test]
fn documents_without_a_compatibility_mode_are_laid_out_as_word_2007() {
    assert_eq!(read_body("<w:p/>").settings.compat_mode, craft_wordmodel::LEGACY_COMPAT_MODE);
}

#[test]
fn style_rfonts_without_ascii_inherits_doc_defaults_font() {
    // Issue #93: Normal names only East Asian / complex-script fonts, so Latin text keeps the
    // docDefaults font. A run hinted as East Asian keeps its East Asian font in `font_ea` (#4031).
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="Calibri" w:eastAsia="Calibri" w:hAnsi="Calibri" w:cs="Calibri"/></w:rPr></w:rPrDefault><w:pPrDefault/></w:docDefaults>
 <w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/><w:rPr><w:rFonts w:eastAsia="Times New Roman" w:cs="Times New Roman"/></w:rPr></w:style>
</w:styles>"#
    );
    let body = r#"<w:p><w:r><w:t>Plain</w:t></w:r></w:p><w:p><w:r><w:rPr><w:rFonts w:hint="eastAsia" w:eastAsia="SimSun"/></w:rPr><w:t>漢字</w:t></w:r></w:p>"#;
    let d = craft_docx::read(&docx(body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    assert_eq!(d.styles.get("Normal").unwrap().chr.font, None);
    let ps = paras(&d);
    let rc = |p: &Paragraph| d.styles.resolve_char(p.props.style.as_deref(), &p.runs[0].props);
    assert_eq!(rc(ps[0]).font, "Calibri");
    assert_eq!((rc(ps[1]).font.as_str(), rc(ps[1]).font_ea.as_deref()), ("Calibri", Some("SimSun")));
}

#[test]
fn hinted_east_asian_or_cs_font_does_not_replace_the_latin_font() {
    // Issue #4031: `w:hint` only picks the font for ambiguous characters, so a run with
    // `w:eastAsia` + `w:hint="eastAsia"` and no `w:ascii` keeps the style's Latin font for its
    // Latin text; the East Asian / complex-script fonts stay in their own fields.
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:style w:type="paragraph" w:styleId="Heading2"><w:name w:val="heading 2"/><w:rPr><w:rFonts w:ascii="Times New Roman" w:hAnsi="Times New Roman" w:cs="Times New Roman" w:eastAsiaTheme="majorEastAsia"/><w:b/></w:rPr></w:style>
</w:styles>"#
    );
    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading2"/></w:pPr><w:r><w:rPr><w:rFonts w:eastAsia="宋体" w:hint="eastAsia"/></w:rPr><w:t>corn straw</w:t></w:r><w:r><w:rPr><w:rFonts w:cs="Arial" w:hint="cs"/></w:rPr><w:t>model fluids</w:t></w:r></w:p>"#;
    let d = craft_docx::read(&docx(body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    let p = paras(&d)[0];
    let ea = d.styles.resolve_char(p.props.style.as_deref(), &p.runs[0].props);
    assert_eq!((ea.font.as_str(), ea.font_ea.as_deref()), ("Times New Roman", Some("宋体")));
    let cs = d.styles.resolve_char(p.props.style.as_deref(), &p.runs[1].props);
    assert_eq!((cs.font.as_str(), cs.font_cs.as_str()), ("Times New Roman", "Arial"));
}

#[test]
fn bare_break_directly_in_paragraph() {
    let body = r#"<w:p><w:r><w:t>First</w:t></w:r><w:br/><w:r><w:t>Second</w:t></w:r><w:cr/><w:br w:type="page"/><w:r><w:t>Third</w:t></w:r></w:p>"#;
    let d = read_body(body);
    assert_eq!(paras(&d)[0].text, "First\nSecond\n\u{C}Third");
    let out = craft_docx::write(&d).unwrap();
    let d2 = craft_docx::read(&out).unwrap();
    assert_eq!(paras(&d2)[0].text, "First\nSecond\n\u{C}Third");
}

/// Issue #1290: Word's text watermark, a VML shape with a `v:textpath` in a header or footer,
/// becomes the document's watermark (drawn on every page) instead of being dropped; other WordArt
/// is not a watermark, and hostile values don't panic.
#[test]
fn vml_textpath_in_header_is_the_watermark() {
    let read = |shape: &str, in_header: bool| {
        let pict = format!("<w:p><w:r><w:t>Header label</w:t></w:r><w:r><w:pict>{shape}</w:pict></w:r></w:p>");
        let header = format!(r#"<w:hdr {W_NS}>{}</w:hdr>"#, if in_header { pict.as_str() } else { "<w:p/>" });
        let body = format!(
            r#"{}<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/></w:sectPr>"#,
            if in_header { "" } else { pict.as_str() }
        );
        let d = craft_docx::read(&docx(&body, &[("rIdH", "header", "header1.xml")], &[("word/header1.xml", &header)])).unwrap();
        let hid = d.last_section.headers.default.unwrap();
        let header_objects = d.parts.get(&hid).unwrap().blocks.iter().filter_map(|b| b.as_para()).map(|p| p.objects.len()).sum::<usize>();
        let header_text = d.parts.get(&hid).unwrap().blocks.first().and_then(|b| b.as_para()).map(|p| p.text.clone()).unwrap_or_default();
        (d.settings.watermark.clone(), header_objects, header_text)
    };

    // Word's Design › Watermark shape: turned 315°, silver, semitransparent, quoted font name.
    let word = r##"<v:shape id="PowerPlusWaterMarkObject1" o:spid="_x0000_s1025" type="#_x0000_t136" style="position:absolute;margin-left:0;margin-top:0;width:412.4pt;height:247.4pt;rotation:315;z-index:-251657216;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin" o:allowincell="f" fillcolor="silver" stroked="f"><v:fill opacity=".5"/><v:textpath style="font-family:&quot;Calibri Light&quot;;font-size:1pt" string="CONFIDENTIAL"/></v:shape>"##;
    let (wm, objects, text) = read(word, true);
    let wm = wm.expect("watermark");
    assert_eq!((wm.text.as_str(), wm.font.as_str(), wm.color), ("CONFIDENTIAL", "Calibri Light", Rgb(0xC0, 0xC0, 0xC0)));
    assert!(wm.diagonal && wm.semitransparent, "{wm:?}");
    // Consumed: not also drawn as a shape in the header, whose text stays.
    assert_eq!((objects, text.as_str()), (0, "Header label"));

    // A page-centred, gray, opaque shape turned -40° (no `v:fill`).
    let gray = r##"<v:shape id="WaterMark" type="#_x0000_t136" style="width:500pt;height:100pt;margin-top:0;margin-left:0;mso-position-horizontal:center;mso-position-horizontal-relative:page;mso-position-vertical:center;mso-position-vertical-relative:page;position:absolute;rotation:-40" fillcolor="gray" strokecolor="gray"><v:textpath style="font-family:Arial" string="BOZZA"/></v:shape>"##;
    let wm = read(gray, true).0.expect("watermark");
    assert_eq!(
        (wm.text.as_str(), wm.font.as_str(), wm.color, wm.diagonal, wm.semitransparent),
        ("BOZZA", "Arial", Rgb(0x80, 0x80, 0x80), true, false)
    );

    // Horizontal, centred both ways without Word's id, opacity in 65536ths.
    let flat = r##"<v:shape type="#_x0000_t136" style="position:absolute;width:300pt;height:60pt;mso-position-horizontal:center;mso-position-vertical:center" fillcolor="#336699"><v:fill opacity="32768f"/><v:textpath string="ASAP"/></v:shape>"##;
    let wm = read(flat, true).0.expect("watermark");
    assert_eq!((wm.color, wm.diagonal, wm.semitransparent), (Rgb(0x33, 0x66, 0x99), false, true));

    // Not watermarks: the same shape in the body (WordArt); header WordArt that isn't centred
    // and isn't Word's watermark (a logo); a textpath turned off; a watermark-like shape inside a
    // header's text box.
    assert_eq!(read(gray, false).0, None);
    let logo = r##"<v:shape type="#_x0000_t136" style="position:absolute;margin-left:0;margin-top:0;width:120pt;height:30pt;mso-position-horizontal:left;mso-position-horizontal-relative:margin" fillcolor="navy"><v:textpath string="ACME"/></v:shape>"##;
    assert_eq!(read(logo, true).0, None);
    assert_eq!(read(&word.replace(r#"<v:textpath "#, r#"<v:textpath on="f" "#), true).0, None);
    let boxed = format!(
        r##"<v:shape type="#_x0000_t202" style="width:200pt;height:100pt"><v:textbox><w:txbxContent><w:p><w:r><w:pict>{word}</w:pict></w:r></w:p></w:txbxContent></v:textbox></v:shape>"##
    );
    assert_eq!(read(&boxed, true).0, None);

    // A footer's watermark counts too, and the first one found wins.
    let footer = format!(r#"<w:ftr {W_NS}><w:p><w:r><w:pict>{gray}</w:pict></w:r></w:p></w:ftr>"#);
    let header = format!(r#"<w:hdr {W_NS}><w:p><w:r><w:pict>{word}</w:pict></w:r></w:p></w:hdr>"#);
    let body = r#"<w:p/><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/><w:footerReference w:type="default" r:id="rIdF"/></w:sectPr>"#;
    let only_footer = r#"<w:p/><w:sectPr><w:footerReference w:type="default" r:id="rIdF"/></w:sectPr>"#;
    let parts = [("word/header1.xml", header.as_str()), ("word/footer1.xml", footer.as_str())];
    let rels = [("rIdH", "header", "header1.xml"), ("rIdF", "footer", "footer1.xml")];
    let wm = |body: &str| craft_docx::read(&docx(body, &rels, &parts)).unwrap().settings.watermark.map(|w| w.text);
    assert_eq!(wm(only_footer).as_deref(), Some("BOZZA"));
    assert_eq!(wm(body).as_deref(), Some("CONFIDENTIAL"));

    // Hostile values: an oversized string is capped, garbage rotation/opacity/colour don't panic,
    // an empty string is no watermark.
    let long = "W".repeat(10_000);
    let hostile = format!(
        r##"<v:shape id="PowerPlusWaterMarkObject9" style="rotation:NaNfd;width:-1e40pt" fillcolor="#zz" ><v:fill opacity="1e99f"/><v:textpath style="font-family:;" string="{long}"/></v:shape>"##
    );
    let wm = read(&hostile, true).0.expect("watermark");
    assert_eq!(wm.text.chars().count(), 200);
    assert!(!wm.font.is_empty());
    assert_eq!(read(r#"<v:shape id="PowerPlusWaterMarkObject2"><v:textpath string="  "/></v:shape>"#, true).0, None);
}

/// Issue #2875: Word 2007 WordArt, a body `v:shape` with a `v:textpath`, is shown as a text shape
/// holding its string in the textpath's font and the shape's colour, bent by the warp of its WordArt
/// shape, not dropped; a textpath turned off or with an empty string draws nothing.
#[test]
fn vml_textpath_in_body_is_shown() {
    let read = |shape: &str| {
        let body = format!("<w:p><w:r><w:t>Before</w:t></w:r><w:r><w:pict>{shape}</w:pict></w:r></w:p>");
        craft_docx::read(&docx(&body, &[], &[])).unwrap()
    };
    let art = r##"<v:shape type="#_x0000_t136" style="position:absolute;width:300pt;height:60pt" fillcolor="#336699" stroked="f"><v:textpath style="font-family:&quot;Impact&quot;;font-size:1pt" string="Sale"/></v:shape>"##;
    let d = read(art);
    let objs = &paras(&d)[0].objects;
    assert_eq!(objs.len(), 1);
    let InlineObject::Shape { story: Some(id), w, h, .. } = &objs[0] else { panic!("not a text shape: {:?}", objs[0]) };
    assert_eq!((*w, *h), (300.0, 60.0));
    let p = d.parts.get(id).unwrap().blocks[0].as_para().unwrap();
    assert_eq!(p.text, "Sale");
    assert_eq!(p.runs[0].props.font.as_deref(), Some("Impact"));
    assert_eq!(p.runs[0].props.color, Some(TextColor::Rgb(Rgb(0x33, 0x66, 0x99))));

    // Its WordArt shape bends the text: shapetype 144 (Arch Up) is DrawingML's `textArchUp`.
    let warp = |shape: &str| match &paras(&read(shape))[0].objects[..] {
        [InlineObject::Shape { extra, .. }] => extra.warp.as_ref().map(|w| w.preset.clone()),
        other => panic!("not one shape: {other:?}"),
    };
    assert_eq!(warp(&art.replace("_x0000_t136", "_x0000_t144")).as_deref(), Some("textArchUp"));
    assert_eq!(warp(&art.replace("_x0000_t136", "_x0000_t175")).as_deref(), Some("textCanDown"));
    assert_eq!(warp(art).as_deref(), Some("textPlain"));

    assert!(paras(&read(&art.replace("<v:textpath ", r#"<v:textpath on="f" "#)))[0].objects.is_empty());
    assert!(paras(&read(&art.replace(r#"string="Sale""#, r#"string=" ""#)))[0].objects.is_empty());
}

/// Issue #1290: a file with Word's watermark keeps it through save and reopen: the same
/// watermark, the same headers with the same text and paragraphs, one shape per header written;
/// header WordArt that isn't a watermark doesn't become one on the way.
#[test]
fn word_watermark_survives_save() {
    let shape = |id: &str, text: &str| {
        format!(
            r##"<w:r><w:pict><v:shapetype id="_x0000_t136" coordsize="21600,21600" o:spt="136" path="m0,0l21600,0m0,21600l21600,21600e"><v:textpath on="t" fitshape="t"/></v:shapetype><v:shape id="{id}" type="#_x0000_t136" style="position:absolute;margin-left:0;margin-top:0;width:412pt;height:247pt;rotation:315;z-index:-251657216;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin" o:allowincell="f" fillcolor="silver" stroked="f"><v:fill opacity=".5"/><v:textpath style="font-family:&quot;Calibri Light&quot;;font-size:1pt" string="{text}"/></v:shape></w:pict></w:r>"##
        )
    };
    let hdr = |inner: &str| {
        format!(r#"<w:hdr {W_NS}><w:p>{inner}<w:r><w:t>Header label</w:t></w:r></w:p><w:p><w:r><w:t>Second line</w:t></w:r></w:p></w:hdr>"#)
    };
    let h1 = hdr(&shape("PowerPlusWaterMarkObject1", "CONFIDENTIAL"));
    let h2 = hdr(&shape("PowerPlusWaterMarkObject2", "CONFIDENTIAL"));
    let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/><w:headerReference w:type="first" r:id="rIdF"/><w:titlePg/></w:sectPr>"#;
    let rels = [("rIdH", "header", "header1.xml"), ("rIdF", "header", "header2.xml")];
    let d = craft_docx::read(&docx(body, &rels, &[("word/header1.xml", &h1), ("word/header2.xml", &h2)])).unwrap();
    let wm = d.settings.watermark.clone().expect("watermark");
    let bytes = craft_docx::write(&d).unwrap();
    let d2 = craft_docx::read(&bytes).unwrap();
    assert_eq!(d2.settings.watermark, Some(wm));
    let headers = |d: &Document| {
        let mut v: Vec<Vec<String>> = [d.last_section.headers.default, d.last_section.headers.first]
            .iter()
            .map(|id| d.parts[&id.unwrap()].blocks.iter().filter_map(|b| b.as_para()).map(|p| p.text.clone()).collect())
            .collect();
        v.push(vec![d.parts.len().to_string()]);
        v
    };
    assert_eq!(headers(&d2), headers(&d));
    assert_eq!(headers(&d2)[0], vec!["Header label".to_string(), "Second line".to_string()]);
    let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
    for name in ["word/header1.xml", "word/header2.xml"] {
        let mut xml = String::new();
        std::io::Read::read_to_string(&mut z.by_name(name).unwrap(), &mut xml).unwrap();
        assert_eq!(xml.matches("<v:shape ").count(), 1, "{name}");
    }

    // A header logo in WordArt isn't a watermark, so none is written.
    let logo = r##"<w:r><w:pict><v:shape type="#_x0000_t136" style="position:absolute;width:120pt;height:30pt;mso-position-horizontal:left" fillcolor="navy"><v:textpath string="ACME"/></v:shape></w:pict></w:r>"##;
    let d = craft_docx::read(&docx(body, &rels, &[("word/header1.xml", &hdr(logo)), ("word/header2.xml", &hdr(""))])).unwrap();
    assert_eq!(d.settings.watermark, None);
    let d2 = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(d2.settings.watermark, None);
}

/// Issue #1775: a picture watermark in a header that starts with a table is anchored in a cell
/// but placed on the page: any VML shape in a header (Word's picture watermark, `o:allowincell="f"`; user-checked
/// in Word for Mac, the attribute makes no difference) or DrawingML `layoutInCell="0"`. That survives save and reopen; a shape laid out in its cell stays so.
#[test]
fn header_cell_picture_placed_on_the_page() {
    let vml = |allow: &str| {
        format!(
            r##"<w:r><w:pict><v:shape id="WordPictureWatermark1" o:spid="_x0000_s2049" type="#_x0000_t75" style="position:absolute;margin-left:0;margin-top:0;width:300pt;height:200pt;z-index:-251657216;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin" {allow}><v:imagedata r:id="rIdP" o:title="" gain="19661f" blacklevel="22938f"/></v:shape></w:pict></w:r>"##
        )
    };
    let anchor = |in_cell: &str| {
        format!(
            r#"<w:r><w:drawing><wp:anchor distT="0" distB="0" distL="0" distR="0" simplePos="0" relativeHeight="1" behindDoc="1" locked="0" layoutInCell="{in_cell}" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="margin"><wp:align>center</wp:align></wp:positionH><wp:positionV relativeFrom="margin"><wp:align>center</wp:align></wp:positionV><wp:extent cx="3810000" cy="2540000"/><wp:wrapNone/><wp:docPr id="1" name="Picture 1"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="1" name="p.png"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="rIdP"/></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="3810000" cy="2540000"/></a:xfrm><a:prstGeom prst="rect"/></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:anchor></w:drawing></w:r>"#
        )
    };
    let read = |run: &str| {
        let hdr = format!(
            r#"<w:hdr {W_NS}><w:tbl><w:tblGrid><w:gridCol w:w="4680"/><w:gridCol w:w="4680"/></w:tblGrid><w:tr><w:tc><w:p><w:r><w:t>Left</w:t></w:r></w:p></w:tc><w:tc><w:p>{run}<w:r><w:t>Right</w:t></w:r></w:p></w:tc></w:tr></w:tbl><w:p/></w:hdr>"#
        );
        let hrels = rels(&[("rIdP", "image", "media/p.png")]);
        let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/></w:sectPr>"#;
        let parts = [("word/header1.xml", hdr.as_str()), ("word/_rels/header1.xml.rels", hrels.as_str()), ("word/media/p.png", "\u{89}PNG stand-in")];
        craft_docx::read(&docx(body, &[("rIdH", "header", "header1.xml")], &parts)).unwrap()
    };
    let floats = |d: &Document| -> Vec<(bool, Wrap)> {
        let hid = d.last_section.headers.default.unwrap();
        let mut out = Vec::new();
        for b in &d.parts[&hid].blocks {
            if let Block::Table(t) = &**b {
                for c in &t.rows[0].cells {
                    for p in c.blocks.iter().filter_map(|b| b.as_para()) {
                        out.extend(p.objects.iter().filter_map(|o| o.frame()).map(|(_, _, f)| (f.outside_cell, f.wrap)));
                    }
                }
            }
        }
        out
    };
    for (run, outside) in [
        (vml(r#"o:allowincell="f""#), true),
        (vml(r#"o:allowincell="false""#), true),
        // Word for Mac draws every VML picture in a header cell on the page, ticked or not.
        (vml(""), true),
        (vml(r#"o:allowincell="t""#), true),
        (anchor("0"), true),
        (anchor("false"), true),
        (anchor("1"), false),
    ] {
        let d = read(&run);
        assert_eq!(floats(&d), vec![(outside, Wrap::BehindText)], "{run}");
        let d2 = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
        assert_eq!(floats(&d2), vec![(outside, Wrap::BehindText)], "saved: {run}");
    }
}

/// Issue #1775: only header and footer shapes are placed on the page from a cell (what was checked
/// in Word); a VML picture in a body table cell stays laid out in its cell.
#[test]
fn body_cell_vml_picture_stays_in_its_cell() {
    let pic = r##"<w:r><w:pict><v:shape type="#_x0000_t75" style="position:absolute;margin-left:0;margin-top:0;width:100pt;height:80pt;z-index:-1;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin"><v:imagedata r:id="rIdP"/></v:shape></w:pict></w:r>"##;
    let body = format!(r#"<w:tbl><w:tblGrid><w:gridCol w:w="4680"/></w:tblGrid><w:tr><w:tc><w:p>{pic}</w:p></w:tc></w:tr></w:tbl><w:p/>"#);
    let parts = [("word/media/p.png", "\u{89}PNG stand-in")];
    let d = craft_docx::read(&docx(&body, &[("rIdP", "image", "media/p.png")], &parts)).unwrap();
    let Block::Table(t) = &*d.body[0] else { panic!("table first") };
    let floats: Vec<bool> = t.rows[0].cells[0]
        .blocks
        .iter()
        .filter_map(|b| b.as_para())
        .flat_map(|p| p.objects.iter().filter_map(|o| o.frame()).map(|(_, _, f)| f.outside_cell))
        .collect();
    assert_eq!(floats, vec![false]);
}

/// Issue #149: an absolutely positioned VML text box in a header floats where its style puts it
/// (relative to the page here, behind the text at a negative z-index, no wrapping) instead of
/// sitting inline in the header's flow, and it keeps that placement when saved and read back.
#[test]
fn absolute_vml_text_box_in_header_floats() {
    let w10 = r#"xmlns:w10="urn:schemas-microsoft-com:office:word""#;
    let boxes = r##"<w:p><w:r><w:pict><v:shape id="Box" type="#_x0000_t202" style="position:absolute;left:0;margin-left:0pt;margin-top:80pt;width:405pt;height:491.4pt;z-index:-1;mso-position-horizontal-relative:page;mso-position-vertical-relative:page"><v:textbox><w:txbxContent><w:p><w:r><w:t>WATERMARK</w:t></w:r></w:p></w:txbxContent></v:textbox><w10:wrap type="none"/></v:shape></w:pict></w:r></w:p>
<w:p><w:r><w:pict><v:rect style="position:absolute;margin-left:12pt;margin-top:-6pt;width:1in;height:36pt;z-index:3;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical-relative:top-margin-area;mso-wrap-distance-left:9pt;mso-wrap-distance-bottom:4pt"><v:textbox><w:txbxContent><w:p><w:r><w:t>square</w:t></w:r></w:p></w:txbxContent></v:textbox><w10:wrap type="square"/></v:rect></w:pict></w:r>
<w:r><w:pict><v:shape style="position:absolute;margin-left:1in;margin-top:2pt;width:72pt;height:20pt;z-index:5"><v:textbox><w:txbxContent><w:p><w:r><w:t>front</w:t></w:r></w:p></w:txbxContent></v:textbox></v:shape></w:pict></w:r>
<w:r><w:pict><v:shape style="width:72pt;height:20pt"><v:textbox><w:txbxContent><w:p><w:r><w:t>inline</w:t></w:r></w:p></w:txbxContent></v:textbox></v:shape></w:pict></w:r></w:p>""##;
    let header = format!(r#"<w:hdr {W_NS} {w10}><w:p><w:r><w:t>Header label</w:t></w:r></w:p>{boxes}</w:hdr>"#);
    let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/></w:sectPr>"#;
    let bytes = docx(body, &[("rIdH", "header", "header1.xml")], &[("word/header1.xml", &header)]);
    let check = |d: &Document| {
        let hid = d.last_section.headers.default.unwrap();
        let blocks = &d.parts.get(&hid).unwrap().blocks;
        let shapes: Vec<_> = blocks
            .iter()
            .filter_map(|b| b.as_para())
            .flat_map(|p| &p.objects)
            .filter_map(|o| {
                if let InlineObject::Shape { kind, w, h, float, story, .. } = o { Some((*kind, *w, *h, float.clone(), *story)) } else { None }
            })
            .collect();
        let [(k0, w0, h0, f0, s0), (_, w1, h1, f1, _), (_, _, _, f2, _), (_, _, _, f3, _)] = shapes.as_slice() else { panic!("{shapes:?}") };
        assert_eq!(*k0, ShapeKind::TextBox);
        assert!((w0 - 405.0).abs() < 0.01 && (h0 - 491.4).abs() < 0.01, "{w0} x {h0}");
        assert_eq!((f0.wrap, f0.h_rel, f0.v_rel, f0.h_align, f0.v_align), (Wrap::BehindText, Anchor::Page, Anchor::Page, None, None));
        assert!(f0.x.abs() < 0.01 && (f0.y - 80.0).abs() < 0.01, "offset {} {}", f0.x, f0.y);
        let text = d.parts.get(&s0.unwrap()).unwrap().blocks[0].as_para().unwrap().text.clone();
        assert_eq!(text, "WATERMARK");
        assert_eq!((*w1, *h1), (72.0, 36.0));
        assert_eq!(
            (f1.wrap, f1.h_rel, f1.h_align, f1.v_rel, f1.v_align),
            (Wrap::Square, Anchor::Margin, Some(FloatAlign::Center), Anchor::TopMargin, None)
        );
        assert!((f1.y + 6.0).abs() < 0.01 && (f1.dist - 9.0).abs() < 0.01 && (f1.dist_bottom - 4.0).abs() < 0.01, "{f1:?}");
        // No wrap element: in front of the text, relative to the column and paragraph.
        assert_eq!((f2.wrap, f2.h_rel, f2.v_rel), (Wrap::InFrontOfText, Anchor::Column, Anchor::Paragraph));
        assert!((f2.x - 72.0).abs() < 0.01 && (f2.y - 2.0).abs() < 0.01, "{f2:?}");
        // Not absolutely positioned: still inline.
        assert_eq!(f3.wrap, Wrap::Inline);
    };
    let d = craft_docx::read(&bytes).unwrap();
    check(&d);
    // Saved (as DrawingML anchors) and read back, the boxes keep their placement.
    check(&craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap());
}

#[test]
fn hostile_vml_style_values_stay_finite() {
    let body = r#"<w:p><w:r><w:pict><v:shape style="position:ABSOLUTE;margin-left:1e39pt;left:-1e39pt;margin-top:NaNpt;top:;width:-5pt;height:1e30in;z-index:99999999999999999999999;mso-position-horizontal:bogus;mso-wrap-distance-left:-3pt;mso-wrap-distance-top:1e9pt;;:;position"><v:textbox><w:txbxContent><w:p/></w:txbxContent></v:textbox></v:shape></w:pict></w:r></w:p>"#;
    let d = read_body(body);
    let p = paras(&d);
    let Some(InlineObject::Shape { w, h, float, .. }) = p[0].objects.first() else { panic!("{:?}", p[0].objects) };
    assert_eq!(float.wrap, Wrap::InFrontOfText);
    assert!([*w, *h, float.x, float.y, float.dist, float.dist_top].iter().all(|v| v.is_finite()), "{w} {h} {float:?}");
    assert_eq!((float.h_align, float.dist, float.dist_top), (None, 0.0, 1584.0));
}

// ---- charts and OLE objects written back (#319) ----

const CHART_XML: &str = r#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><c:chart><c:plotArea><c:barChart><c:ser><c:val><c:numLit><c:ptCount val="2"/><c:pt idx="0"><c:v>1</c:v></c:pt><c:pt idx="1"><c:v>2</c:v></c:pt></c:numLit></c:val></c:ser></c:barChart></c:plotArea></c:chart><c:externalData r:id="rId1"><c:autoUpdate val="0"/></c:externalData></c:chartSpace>"#;
/// Stands in for the chart's workbook: opaque bytes, never opened.
const WORKBOOK: &str = "PK\u{3}\u{4} not really a workbook";
const COLORS_XML: &str = r#"<cs:colorStyle xmlns:cs="http://schemas.microsoft.com/office/drawing/2012/chartStyle" meth="cycle" id="10"/>"#;
const CT_CHART: &str = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
const CT_XLSX: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";

/// A package holding one inline chart (3 × 1.5 in) with its workbook and colour style parts.
fn chart_docx() -> Vec<u8> {
    let body = r#"<w:p><w:r><w:t>Sales</w:t></w:r><w:r><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="2743200" cy="1371600"/><wp:docPr id="1" name="Chart 1"/><wp:cNvGraphicFramePr/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" r:id="rId7"/></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>"#;
    let chart_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/package" Target="../embeddings/Microsoft_Excel_Worksheet.xlsx"/><Relationship Id="rId2" Type="http://schemas.microsoft.com/office/2011/relationships/chartColorStyle" Target="colors1.xml"/></Relationships>"#;
    let types = format!(
        r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Default Extension="xlsx" ContentType="{CT_XLSX}"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/charts/chart1.xml" ContentType="{CT_CHART}"/><Override PartName="/word/charts/colors1.xml" ContentType="application/vnd.ms-office.chartcolorstyle+xml"/></Types>"#
    );
    docx(
        body,
        &[("rId7", "chart", "charts/chart1.xml")],
        &[
            ("[Content_Types].xml", &types),
            ("word/charts/chart1.xml", CHART_XML),
            ("word/charts/_rels/chart1.xml.rels", chart_rels),
            ("word/charts/colors1.xml", COLORS_XML),
            ("word/embeddings/Microsoft_Excel_Worksheet.xlsx", WORKBOOK),
        ],
    )
}

/// The entries of a zip, by name.
fn unzip(bytes: &[u8]) -> std::collections::BTreeMap<String, Vec<u8>> {
    use std::io::Read;
    let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
    let mut out = std::collections::BTreeMap::new();
    for i in 0..z.len() {
        let mut f = z.by_index(i).unwrap();
        let mut b = Vec::new();
        f.read_to_end(&mut b).unwrap();
        out.insert(f.name().unwrap().to_string(), b);
    }
    out
}

fn text(files: &std::collections::BTreeMap<String, Vec<u8>>, name: &str) -> String {
    String::from_utf8(files.get(name).unwrap_or_else(|| panic!("no {name} in {:?}", files.keys())).clone()).unwrap()
}

/// Values of attribute `attr` on the elements named `el` (in written order).
fn attr_values(xml: &str, el: &str, attr: &str) -> Vec<String> {
    let start = |s: &str| format!(" {}", s.split('>').next().unwrap_or(""));
    xml.split(&format!("<{el} "))
        .skip(1)
        .filter_map(|s| start(s).split(&format!(" {attr}=\"")).nth(1)?.split('"').next().map(str::to_string))
        .collect()
}

/// (type, target) of relationship `id` in a relationships part.
fn rel(rels: &str, id: &str) -> (String, String) {
    let r = rels.split("<Relationship ").find(|r| r.contains(&format!("Id=\"{id}\""))).unwrap_or_else(|| panic!("no {id} in {rels}"));
    let get = |a: &str| r.split(&format!("{a}=\"")).nth(1).unwrap().split('"').next().unwrap().to_string();
    (get("Type"), get("Target"))
}

/// Package part a relationship target of `from_dir` names.
fn part_at(from_dir: &str, target: &str) -> String {
    let mut parts: Vec<&str> = from_dir.split('/').filter(|s| !s.is_empty()).collect();
    for seg in target.split('/') {
        match seg {
            ".." => {
                parts.pop();
            }
            "." | "" => {}
            s => parts.push(s),
        }
    }
    parts.join("/")
}

/// Checks a written chart: its part and the parts it relates to are all in the package, with the
/// original bytes and content types. Returns the chart's part name.
fn check_chart(files: &std::collections::BTreeMap<String, Vec<u8>>, rid: &str) -> String {
    let (kind, target) = rel(&text(files, "word/_rels/document.xml.rels"), rid);
    assert!(kind.ends_with("/chart"), "{kind}");
    let chart = part_at("word", &target);
    assert_eq!(text(files, &chart), CHART_XML);
    let (dir, file) = chart.rsplit_once('/').unwrap();
    let chart_rels = text(files, &format!("{dir}/_rels/{file}.rels"));
    let (kind, wb) = rel(&chart_rels, "rId1");
    assert!(kind.ends_with("/package"), "{kind}");
    let wb = part_at(dir, &wb);
    assert_eq!(files.get(&wb).map(Vec::as_slice), Some(WORKBOOK.as_bytes()), "{wb}");
    let (kind, colors) = rel(&chart_rels, "rId2");
    assert!(kind.ends_with("/chartColorStyle"), "{kind}");
    assert_eq!(text(files, &part_at(dir, &colors)), COLORS_XML);
    let types = text(files, "[Content_Types].xml");
    assert!(types.contains(&format!(r#"PartName="/{chart}" ContentType="{CT_CHART}""#)), "{types}");
    assert!(types.contains(&format!(r#"PartName="/{wb}" ContentType="{CT_XLSX}""#)), "{types}");
    chart
}

fn graphics(d: &Document) -> Vec<InlineObject> {
    paras(d).iter().flat_map(|p| p.objects.iter()).filter(|o| matches!(o, InlineObject::Graphic { .. })).cloned().collect()
}

#[test]
fn chart_round_trips_with_its_parts() {
    let d = craft_docx::read(&chart_docx()).unwrap();
    let out = craft_docx::write(&d).unwrap();
    let files = unzip(&out);
    let body = text(&files, "word/document.xml");
    let ids = attr_values(&body, "c:chart", "r:id");
    assert_eq!(ids.len(), 1, "{body}");
    assert_eq!(check_chart(&files, &ids[0]), "word/charts/chart1.xml");
    assert_eq!(attr_values(&body, "wp:extent", "cx"), ["2743200"]);

    // Read back: still drawn, and a second save still carries it.
    let back = craft_docx::read(&out).unwrap();
    let g = graphics(&back);
    let [InlineObject::Graphic { w, graphic, .. }] = g.as_slice() else { panic!("{g:?}") };
    assert_eq!(*w, 216.0);
    assert!(!graphic.items.is_empty() && graphic.source.is_some());
    let again = unzip(&craft_docx::write(&back).unwrap());
    let ids = attr_values(&text(&again, "word/document.xml"), "c:chart", "r:id");
    check_chart(&again, &ids[0]);
}

// ---- Office 2016 charts (cx:chart) written back with their fallback picture (#997) ----

const CHARTEX_NS: &str = "http://schemas.microsoft.com/office/drawing/2014/chartex";
const CHARTEX_XML: &str = r#"<cx:chartSpace xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><cx:chartData><cx:externalData r:id="rId1" cx:autoUpdate="0"/></cx:chartData><cx:chart><cx:plotArea><cx:plotAreaRegion><cx:series layoutId="boxWhisker"/></cx:plotAreaRegion></cx:plotArea></cx:chart></cx:chartSpace>"#;
const CT_CHARTEX: &str = "application/vnd.ms-office.chartex+xml";

/// A package holding one box & whisker chart the way Word writes it: the `cx:chart` in an
/// `mc:Choice` requiring `requires` (bound to `requires_ns`), a picture of it in the `mc:Fallback`.
fn chartex_docx(requires: &str, requires_ns: &str) -> Vec<u8> {
    chartex_docx_linked(requires, requires_ns, false)
}

/// [`chartex_docx`], its drawing linked to a web address (`wp:docPr/a:hlinkClick`) when `link`,
/// after a first choice linked elsewhere, which needs a namespace no reader knows, so a reader
/// takes the chart's choice.
fn chartex_docx_linked(requires: &str, requires_ns: &str, link: bool) -> Vec<u8> {
    let click = if link { r#"<a:hlinkClick r:id="rIdWeb"/>"# } else { "" };
    let other = if link {
        r#"<mc:Choice xmlns:w99="urn:example:unsupported" Requires="w99"><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="254000" cy="254000"/><wp:docPr id="9" name="Other"><a:hlinkClick r:id="rIdOther"/></wp:docPr><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp><wps:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></wps:spPr><wps:bodyPr/></wps:wsp></a:graphicData></a:graphic></wp:inline></w:drawing></mc:Choice>"#
    } else {
        ""
    };
    let frame = format!(
        r#"<wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="2743200" cy="1371600"/><wp:docPr id="1" name="Chart 1">{click}</wp:docPr><wp:cNvGraphicFramePr/>"#
    );
    let body = format!(
        r#"<w:p><w:r><w:t>Spread</w:t></w:r><w:r><mc:AlternateContent>{other}<mc:Choice xmlns:{requires}="{requires_ns}" Requires="{requires}"><w:drawing>{frame}<a:graphic><a:graphicData uri="{CHARTEX_NS}"><cx:chart xmlns:cx="{CHARTEX_NS}" r:id="rIdCx"/></a:graphicData></a:graphic></wp:inline></w:drawing></mc:Choice><mc:Fallback><w:drawing>{frame}<a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="1" name="Chart 1"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="rIdPic"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="2743200" cy="1371600"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></mc:Fallback></mc:AlternateContent></w:r></w:p>"#
    );
    let doc = format!(r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document {W_NS}><w:body>{body}</w:body></w:document>"#);
    let doc_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rIdCx" Type="http://schemas.microsoft.com/office/2014/relationships/chartEx" Target="charts/chartEx1.xml"/><Relationship Id="rIdPic" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/image1.png"/><Relationship Id="rIdWeb" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="https://example.com/chart" TargetMode="External"/><Relationship Id="rIdOther" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="https://example.com/other" TargetMode="External"/></Relationships>"#;
    let chart_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/package" Target="../embeddings/Microsoft_Excel_Worksheet.xlsx"/><Relationship Id="rId2" Type="http://schemas.microsoft.com/office/2011/relationships/chartColorStyle" Target="colors1.xml"/></Relationships>"#;
    let types = format!(
        r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Default Extension="png" ContentType="image/png"/><Default Extension="xlsx" ContentType="{CT_XLSX}"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/charts/chartEx1.xml" ContentType="{CT_CHARTEX}"/><Override PartName="/word/charts/colors1.xml" ContentType="application/vnd.ms-office.chartcolorstyle+xml"/></Types>"#
    );
    zip(&[
        ("[Content_Types].xml", types.as_bytes()),
        ("_rels/.rels", ROOT_RELS.as_bytes()),
        ("word/document.xml", doc.as_bytes()),
        ("word/_rels/document.xml.rels", doc_rels.as_bytes()),
        ("word/charts/chartEx1.xml", CHARTEX_XML.as_bytes()),
        ("word/charts/_rels/chartEx1.xml.rels", chart_rels.as_bytes()),
        ("word/charts/colors1.xml", COLORS_XML.as_bytes()),
        ("word/embeddings/Microsoft_Excel_Worksheet.xlsx", WORKBOOK.as_bytes()),
        ("word/media/image1.png", b"fallback picture bytes"),
    ])
}

#[test]
fn office_2016_chart_keeps_its_chart_part_and_fallback_through_saves() {
    // Word binds `cx1`… to the chart type's own namespace; Apache POI's sample binds `cx`.
    for (requires, requires_ns) in [("cx1", "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex"), ("cx", CHARTEX_NS)] {
        let mut d = craft_docx::read(&chartex_docx(requires, requires_ns)).unwrap();
        for _ in 0..2 {
            let g = graphics(&d);
            let [InlineObject::Graphic { w, graphic, .. }] = g.as_slice() else { panic!("{requires}: {g:?}") };
            assert_eq!(*w, 216.0);
            assert!(
                graphic.items.iter().any(|i| matches!(i, craft_wordmodel::graphic::GraphicItem::Image { media, .. } if d.media.contains_key(media))),
                "{requires}: the chart shows its fallback picture"
            );
            let files = unzip(&craft_docx::write(&d).unwrap());
            let body = text(&files, "word/document.xml");
            assert_eq!(attr_values(&body, "mc:Choice", "Requires"), [requires], "{body}");
            assert!(body.contains(&format!(r#"xmlns:{requires}="{requires_ns}""#)), "{requires} is declared: {body}");
            let doc_rels = text(&files, "word/_rels/document.xml.rels");
            let [cx_id] = attr_values(&body, "cx:chart", "r:id").try_into().unwrap_or_else(|_| panic!("chart lost: {body}"));
            let (kind, target) = rel(&doc_rels, &cx_id);
            assert!(kind.ends_with("/chartEx"), "{kind}");
            let chart = part_at("word", &target);
            assert_eq!(text(&files, &chart), CHARTEX_XML);
            let types = text(&files, "[Content_Types].xml");
            assert!(types.contains(&format!(r#"PartName="/{chart}" ContentType="{CT_CHARTEX}""#)), "{types}");
            let (dir, file) = chart.rsplit_once('/').unwrap();
            let (_, wb) = rel(&text(&files, &format!("{dir}/_rels/{file}.rels")), "rId1");
            assert_eq!(files.get(&part_at(dir, &wb)).map(Vec::as_slice), Some(WORKBOOK.as_bytes()));
            let fallback = body.split("<mc:Fallback>").nth(1).unwrap_or_else(|| panic!("no fallback: {body}"));
            let [pic_id] = attr_values(fallback, "a:blip", "r:embed").try_into().unwrap_or_else(|_| panic!("fallback picture lost: {body}"));
            assert_eq!(files.get(&part_at("word", &rel(&doc_rels, &pic_id).1)).map(Vec::as_slice), Some(&b"fallback picture bytes"[..]));
            assert!(attr_values(&body, "wp:docPr", "name").iter().all(|n| n.starts_with("Chart ")), "{body}");
            let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
            d = craft_docx::read(&zip(&entries)).unwrap();
        }
    }
}

/// #5267: a link on an Office 2016 chart's drawing is the chart's link (not an earlier choice's),
/// and saving keeps it on both branches (the writer rebuilds their frames).
#[test]
fn a_link_on_an_office_2016_charts_drawing_is_kept() {
    let mut d = craft_docx::read(&chartex_docx_linked("cx1", "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex", true)).unwrap();
    for _ in 0..2 {
        let p = d.body[0].as_para().unwrap();
        let off = p.object_offsets().into_iter().find(|o| matches!(p.object_at(*o), Some(InlineObject::Graphic { .. }))).unwrap();
        assert_eq!(p.props_of_char(off).link.as_deref(), Some("https://example.com/chart"));
        let files = unzip(&craft_docx::write(&d).unwrap());
        let body = text(&files, "word/document.xml");
        let ids = attr_values(&body, "a:hlinkClick", "r:id");
        assert_eq!(ids.len(), 2, "on the chart and its fallback picture: {body}");
        assert_eq!(rel(&text(&files, "word/_rels/document.xml.rels"), &ids[0]).1, "https://example.com/chart");
        let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
        d = craft_docx::read(&zip(&entries)).unwrap();
    }
}

#[test]
fn resized_office_2016_chart_resizes_its_fallback_too() {
    let mut d = craft_docx::read(&chartex_docx("cx1", "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex")).unwrap();
    if let Some(Block::Para(p)) = d.body.first_mut().map(std::sync::Arc::make_mut)
        && let Some(InlineObject::Graphic { w, h, .. }) = p.objects.first_mut()
    {
        (*w, *h) = (288.0, 144.0);
    }
    let body = text(&unzip(&craft_docx::write(&d).unwrap()), "word/document.xml");
    assert_eq!(attr_values(&body, "wp:extent", "cx"), ["3657600", "3657600"], "{body}");
}

#[test]
fn moved_and_copied_chart_keeps_its_parts() {
    let d = craft_docx::read(&chart_docx()).unwrap();
    let g = graphics(&d);
    let [InlineObject::Graphic { alt, graphic, .. }] = g.as_slice() else { panic!("{g:?}") };
    // Resized and dragged to float on the page in WordCraft, then copied and pasted.
    let float = craft_wordmodel::para::Float { wrap: Wrap::Square, h_rel: Anchor::Page, v_rel: Anchor::Page, x: 36.0, y: 18.0, ..Default::default() };
    let moved = InlineObject::Graphic { w: 288.0, h: 144.0, alt: alt.clone(), float, graphic: graphic.clone() };
    let mut p = Paragraph::new();
    p.insert_object(0, moved.clone(), &Default::default()).unwrap();
    p.insert_object(p.len(), moved, &Default::default()).unwrap();
    let mut doc = d.clone();
    doc.body = vec![craft_wordmodel::para_block(p)];

    let out = craft_docx::write(&doc).unwrap();
    let files = unzip(&out);
    let body = text(&files, "word/document.xml");
    assert_eq!(attr_values(&body, "wp:extent", "cx"), ["3657600", "3657600"], "the new size");
    assert_eq!(body.matches("<wp:posOffset>457200</wp:posOffset>").count(), 2, "the new position");
    let ids = attr_values(&body, "c:chart", "r:id");
    assert_eq!(ids.len(), 2);
    let charts: Vec<String> = ids.iter().map(|id| check_chart(&files, id)).collect();
    assert_ne!(charts[0], charts[1], "each copy has its own chart part");

    let back = craft_docx::read(&out).unwrap();
    let g = graphics(&back);
    assert_eq!(g.len(), 2);
    for o in &g {
        let InlineObject::Graphic { w, float, graphic, .. } = o else { panic!() };
        assert_eq!((*w, float.wrap, float.x), (288.0, Wrap::Square, 36.0));
        assert!(!graphic.items.is_empty() && graphic.source.is_some());
    }
}

#[test]
fn ole_object_round_trips() {
    let body = r##"<w:p><w:r><w:object w:dxaOrig="1440" w:dyaOrig="720"><v:shape id="_x0000_i1025" type="#_x0000_t75" style="width:72pt;height:36pt" o:ole=""><v:imagedata r:id="rId8" o:title=""/></v:shape><o:OLEObject Type="Embed" ProgID="Package" ShapeID="_x0000_i1025" DrawAspect="Content" ObjectID="_1000000001" r:id="rId9"/></w:object></w:r></w:p>"##;
    let picture = "\u{89}PNG stand-in";
    let ole = "\u{d0}\u{cf} opaque OLE storage";
    let types = r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="png" ContentType="image/png"/><Default Extension="bin" ContentType="application/vnd.openxmlformats-officedocument.oleObject"/></Types>"#;
    let bytes = docx(
        body,
        &[("rId8", "image", "media/image1.png"), ("rId9", "oleObject", "embeddings/oleObject1.bin")],
        &[("[Content_Types].xml", types), ("word/media/image1.png", picture), ("word/embeddings/oleObject1.bin", ole)],
    );
    let d = craft_docx::read(&bytes).unwrap();
    let Some(InlineObject::Image { w, ole: Some(_), .. }) = paras(&d)[0].objects.first() else { panic!("{:?}", paras(&d)[0].objects) };
    assert_eq!(*w, 72.0);

    // Resized in WordCraft.
    let mut doc = d.clone();
    if let Some(craft_wordmodel::Block::Para(p)) = doc.body.first_mut().map(std::sync::Arc::make_mut)
        && let Some(InlineObject::Image { w, h, .. }) = p.objects.first_mut()
    {
        (*w, *h) = (144.0, 72.0);
    }
    let out = craft_docx::write(&doc).unwrap();
    let files = unzip(&out);
    let body = text(&files, "word/document.xml");
    let rels = text(&files, "word/_rels/document.xml.rels");
    assert_eq!(attr_values(&body, "v:shape", "style"), ["width:144pt;height:72pt"]);
    let [ole_id] = attr_values(&body, "o:OLEObject", "r:id").try_into().unwrap();
    let (kind, target) = rel(&rels, &ole_id);
    assert!(kind.ends_with("/oleObject"), "{kind}");
    let ole_part = part_at("word", &target);
    assert_eq!(files.get(&ole_part).map(Vec::as_slice), Some(ole.as_bytes()));
    assert!(
        text(&files, "[Content_Types].xml")
            .contains(&format!(r#"PartName="/{ole_part}" ContentType="application/vnd.openxmlformats-officedocument.oleObject""#))
    );
    let [pic_id] = attr_values(&body, "v:imagedata", "r:id").try_into().unwrap();
    let (kind, target) = rel(&rels, &pic_id);
    assert!(kind.ends_with("/image"), "{kind}");
    assert_eq!(files.get(&part_at("word", &target)).map(Vec::as_slice), Some(picture.as_bytes()));
    assert!(!body.contains("<w:drawing>"), "the object, not a plain picture");

    let back = craft_docx::read(&out).unwrap();
    assert!(matches!(paras(&back)[0].objects.first(), Some(InlineObject::Image { w: 144.0, ole: Some(_), .. })));
}

#[test]
fn an_unqualified_relationship_attribute_round_trips() {
    // A producer that left the relationship prefix out: the VML picture names its image with an
    // unqualified `id`. The reader resolves it (the alias `El::attr` accepts), the writer keeps
    // the attribute and gives it the id the new package holds the image under.
    let body = r##"<w:p><w:r><w:object w:dxaOrig="1440" w:dyaOrig="720"><v:shape id="_x0000_i1025" type="#_x0000_t75" style="width:72pt;height:36pt" o:ole=""><v:imagedata id="rId8" o:title=""/></v:shape><o:OLEObject Type="Embed" ProgID="Package" ShapeID="_x0000_i1025" DrawAspect="Content" ObjectID="_1000000001" r:id="rId9"/></w:object></w:r></w:p>"##;
    let picture = "\u{89}PNG stand-in";
    let ole = "\u{d0}\u{cf} opaque OLE storage";
    let types = r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="png" ContentType="image/png"/><Default Extension="bin" ContentType="application/vnd.openxmlformats-officedocument.oleObject"/></Types>"#;
    let bytes = docx(
        body,
        &[("rId8", "image", "media/image1.png"), ("rId9", "oleObject", "embeddings/oleObject1.bin")],
        &[("[Content_Types].xml", types), ("word/media/image1.png", picture), ("word/embeddings/oleObject1.bin", ole)],
    );
    let d = craft_docx::read(&bytes).unwrap();
    let Some(InlineObject::Image { ole: Some(_), .. }) = paras(&d)[0].objects.first() else { panic!("{:?}", paras(&d)[0].objects) };

    let out = craft_docx::write(&d).unwrap();
    let files = unzip(&out);
    let body = text(&files, "word/document.xml");
    let rels = text(&files, "word/_rels/document.xml.rels");
    // The attribute is still unqualified, and names the image the new package holds.
    let [pic_id] = attr_values(&body, "v:imagedata", "id").try_into().unwrap();
    let (kind, target) = rel(&rels, &pic_id);
    assert!(kind.ends_with("/image"), "{kind}");
    assert_eq!(files.get(&part_at("word", &target)).map(Vec::as_slice), Some(picture.as_bytes()));
    // The object itself is kept whole, as before.
    let [ole_id] = attr_values(&body, "o:OLEObject", "r:id").try_into().unwrap();
    let (kind, target) = rel(&rels, &ole_id);
    assert!(kind.ends_with("/oleObject"), "{kind}");
    assert_eq!(files.get(&part_at("word", &target)).map(Vec::as_slice), Some(ole.as_bytes()));
}

#[test]
fn signature_line_round_trips() {
    // Insert › Signature Line: a VML picture (the line, its X and the signer drawn in a metafile)
    // with an `o:signatureline` that makes it signable in Word. Saving keeps it a signature line,
    // not a plain picture; a VML picture without one still becomes a DrawingML picture.
    let body = r##"<w:p><w:r><w:pict><v:shapetype id="_x0000_t75" coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f"><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"/><o:lock v:ext="edit" aspectratio="t"/></v:shapetype><v:shape id="_x0000_i1025" type="#_x0000_t75" alt="Signature line" style="width:192pt;height:96pt"><v:imagedata r:id="rId8" o:title=""/><o:lock v:ext="edit" ungrouping="t" rotation="t" cropping="t" verticies="t" text="t" grouping="t"/><o:signatureline v:ext="edit" id="{00000000-0000-0000-0000-000000000001}" provid="{00000000-0000-0000-0000-000000000000}" o:suggestedsigner="A. Example" o:suggestedsigner2="Director" showsigndate="f" issignatureline="t"/></v:shape></w:pict></w:r><w:r><w:pict><v:shape style="width:72pt;height:36pt" alt="plain"><v:imagedata r:id="rId8" o:title=""/></v:shape></w:pict></w:r></w:p>"##;
    let picture = "\u{89}PNG stand-in";
    let types =
        r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="png" ContentType="image/png"/></Types>"#;
    let bytes = docx(body, &[("rId8", "image", "media/image1.png")], &[("[Content_Types].xml", types), ("word/media/image1.png", picture)]);
    let d = craft_docx::read(&bytes).unwrap();
    let objects = &paras(&d)[0].objects;
    let [InlineObject::Image { w, alt, ole: Some(_), .. }, InlineObject::Image { ole: None, .. }] = objects.as_slice() else { panic!("{objects:?}") };
    assert_eq!((*w, alt.as_str()), (192.0, "Signature line"));

    // Resized in WordCraft.
    let mut doc = d.clone();
    if let Some(craft_wordmodel::Block::Para(p)) = doc.body.first_mut().map(std::sync::Arc::make_mut)
        && let Some(InlineObject::Image { w, h, .. }) = p.objects.first_mut()
    {
        (*w, *h) = (144.0, 72.0);
    }
    let out = craft_docx::write(&doc).unwrap();
    let files = unzip(&out);
    let body = text(&files, "word/document.xml");
    let rels = text(&files, "word/_rels/document.xml.rels");
    assert_eq!(attr_values(&body, "o:signatureline", "o:suggestedsigner"), ["A. Example"]);
    assert_eq!(attr_values(&body, "o:signatureline", "o:suggestedsigner2"), ["Director"]);
    assert_eq!(attr_values(&body, "v:shape", "style"), ["width:144pt;height:72pt"]);
    assert_eq!(attr_values(&body, "v:shapetype", "id"), ["_x0000_t75"]);
    let [pic_id] = attr_values(&body, "v:imagedata", "r:id").try_into().unwrap();
    let (kind, target) = rel(&rels, &pic_id);
    assert!(kind.ends_with("/image"), "{kind}");
    assert_eq!(files.get(&part_at("word", &target)).map(Vec::as_slice), Some(picture.as_bytes()));
    assert_eq!(body.matches("<w:drawing>").count(), 1, "only the plain picture becomes a DrawingML picture");

    let back = craft_docx::read(&out).unwrap();
    assert!(matches!(paras(&back)[0].objects.first(), Some(InlineObject::Image { w: 144.0, ole: Some(_), .. })));
}

#[test]
fn hostile_embedded_relationships_stay_bounded() {
    // The chart relates to itself, the main document, a relationships part and a missing part;
    // another drawing uses an id with no relationship. Reading and saving neither loop nor carry
    // those along, and the chart is still written back.
    let chart_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="x/package" Target="chart1.xml"/><Relationship Id="rId2" Type="x/a" Target="../document.xml"/><Relationship Id="rId3" Type="x/b" Target="../_rels/document.xml.rels"/><Relationship Id="rId4" Type="x/c" Target="gone.bin"/><Relationship Id="rId4" Type="x/d" Target="chart1.xml"/></Relationships>"#;
    let drawing = |id: &str| {
        format!(
            r#"<w:r><w:drawing><wp:inline><wp:extent cx="2743200" cy="1371600"/><wp:docPr id="1" name="C"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart"><c:chart xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" r:id="{id}"/></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#
        )
    };
    let body = format!("<w:p>{}{}</w:p>", drawing("rId7"), drawing("rIdNowhere"));
    let bytes = docx(
        &body,
        &[("rId7", "chart", "charts/chart1.xml")],
        &[("word/charts/chart1.xml", CHART_XML), ("word/charts/_rels/chart1.xml.rels", chart_rels)],
    );
    let d = craft_docx::read(&bytes).unwrap();
    let g = graphics(&d);
    assert_eq!(g.len(), 2);
    let sources: Vec<bool> = g.iter().map(|o| matches!(o, InlineObject::Graphic { graphic, .. } if graphic.source.is_some())).collect();
    assert_eq!(sources, [true, false], "a dangling id can't be written back");
    let files = unzip(&craft_docx::write(&d).unwrap());
    let body = text(&files, "word/document.xml");
    let [id] = attr_values(&body, "c:chart", "r:id").try_into().unwrap();
    let chart = part_at("word", &rel(&text(&files, "word/_rels/document.xml.rels"), &id).1);
    let rels = text(&files, "word/charts/_rels/chart1.xml.rels");
    assert_eq!(rel(&rels, "rId1").1, "chart1.xml", "its relationship to itself, to the same written part");
    assert!(!rels.contains("document.xml") && !rels.contains("gone.bin") && rels.matches("Id=\"rId4\"").count() <= 1, "{rels}");
    assert_eq!(text(&files, &chart), CHART_XML);
    assert_eq!(files.keys().filter(|k| k.starts_with("word/charts/") && !k.contains("_rels")).count(), 1);
}

/// A group as Word saves one (in `mc:AlternateContent`, needing `wpg`): its members' space
/// starts at `a:chOff`, and a nested group is flattened into it through its own transform.
#[test]
fn word_group_with_nested_group() {
    let body = r#"<w:p><w:r><mc:AlternateContent><mc:Choice Requires="wpg"><w:drawing><wp:anchor behindDoc="0" distT="0" distB="0" distL="114300" distR="114300" simplePos="0" relativeHeight="1" locked="0" layoutInCell="1" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="column"><wp:posOffset>0</wp:posOffset></wp:positionH><wp:positionV relativeFrom="paragraph"><wp:posOffset>0</wp:posOffset></wp:positionV><wp:extent cx="2540000" cy="1270000"/><wp:effectExtent l="0" t="0" r="0" b="0"/><wp:wrapSquare wrapText="bothSides"/><wp:docPr id="1" name="Group 1"/><wp:cNvGraphicFramePr/>
<a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup"><wpg:wgp><wpg:cNvGrpSpPr/><wpg:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="2540000" cy="1270000"/><a:chOff x="127000" y="127000"/><a:chExt cx="2540000" cy="1270000"/></a:xfrm></wpg:grpSpPr>
<wps:wsp><wps:cNvPr id="2" name="Rectangle 2"/><wps:cNvSpPr/><wps:spPr><a:xfrm><a:off x="127000" y="127000"/><a:ext cx="1270000" cy="635000"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></wps:spPr><wps:bodyPr/></wps:wsp>
<wpg:grpSp><wpg:cNvGrpSpPr/><wpg:grpSpPr><a:xfrm><a:off x="1397000" y="762000"/><a:ext cx="1270000" cy="635000"/><a:chOff x="0" y="0"/><a:chExt cx="2540000" cy="1270000"/></a:xfrm></wpg:grpSpPr>
<wps:wsp><wps:cNvPr id="3" name="Oval 3"/><wps:cNvSpPr/><wps:spPr><a:xfrm><a:off x="254000" y="254000"/><a:ext cx="508000" cy="254000"/></a:xfrm><a:prstGeom prst="ellipse"><a:avLst/></a:prstGeom></wps:spPr><wps:bodyPr/></wps:wsp>
</wpg:grpSp></wpg:wgp></a:graphicData></a:graphic></wp:anchor></w:drawing></mc:Choice><mc:Fallback><w:pict/></mc:Fallback></mc:AlternateContent></w:r></w:p>"#;
    let d = read_body(body);
    let p = paras(&d);
    let InlineObject::Group { w, h, float, ch_w, ch_h, children, .. } = &p[0].objects[0] else { panic!("{:?}", p[0].objects) };
    assert_eq!((*w, *h, *ch_w, *ch_h), (200.0, 100.0, 200.0, 100.0));
    assert_eq!(float.wrap, Wrap::Square);
    let got: Vec<(f32, f32, ShapeKind, f32, f32)> = children
        .iter()
        .map(|c| match &c.obj {
            InlineObject::Shape { kind, w, h, .. } => (c.x, c.y, *kind, *w, *h),
            o => panic!("{o:?}"),
        })
        .collect();
    assert_eq!(got, [(0.0, 0.0, ShapeKind::Rectangle, 100.0, 50.0), (110.0, 60.0, ShapeKind::Ellipse, 20.0, 10.0)]);
}

/// The first object of the first paragraph, made mutable.
fn first_object(doc: &mut Document) -> &mut InlineObject {
    let Some(craft_wordmodel::Block::Para(p)) = doc.body.first_mut().map(std::sync::Arc::make_mut) else { panic!("a paragraph") };
    p.objects.first_mut().expect("an object")
}

/// #319 with #332: an OLE object turned or flipped in WordCraft is written back turned, in its VML
/// shape (`rotation`, `flip`) and in a DrawingML picture (`a:xfrm` rot/flipH/flipV, with the
/// effect extent covering the rotated bounds like other drawings).
#[test]
fn rotated_ole_objects_round_trip() {
    let picture = "\u{89}PNG stand-in";
    let ole = "\u{d0}\u{cf} opaque OLE storage";
    let types = r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="png" ContentType="image/png"/><Default Extension="bin" ContentType="application/vnd.openxmlformats-officedocument.oleObject"/></Types>"#;
    let parts = [("[Content_Types].xml", types), ("word/media/image1.png", picture), ("word/embeddings/oleObject1.bin", ole)];
    let doc_rels = [("rId8", "image", "media/image1.png"), ("rId9", "oleObject", "embeddings/oleObject1.bin")];
    let spin = |o: &InlineObject| o.frame().map(|f| f.2.spin()).unwrap();

    // VML: read turned, written with the new turn.
    let vml = r##"<w:p><w:r><w:object w:dxaOrig="1440" w:dyaOrig="720"><v:shape id="_x0000_i1025" type="#_x0000_t75" style="width:72pt;height:36pt;rotation:30;flip:x" o:ole=""><v:imagedata r:id="rId8" o:title=""/></v:shape><o:OLEObject Type="Embed" ProgID="Package" ShapeID="_x0000_i1025" DrawAspect="Content" ObjectID="_1000000001" r:id="rId9"/></w:object></w:r></w:p>"##;
    let mut d = craft_docx::read(&docx(vml, &doc_rels, &parts)).unwrap();
    assert_eq!(spin(&paras(&d)[0].objects[0]), craft_wordmodel::geom::Spin::new(30.0, true, false));
    if let Some(f) = first_object(&mut d).float_mut() {
        f.set_spin(craft_wordmodel::geom::Spin::new(45.0, false, true));
    }
    let out = craft_docx::write(&d).unwrap();
    let body = text(&unzip(&out), "word/document.xml");
    assert_eq!(attr_values(&body, "v:shape", "style"), ["width:72pt;height:36pt;rotation:45;flip:y"]);
    let back = craft_docx::read(&out).unwrap();
    assert!(matches!(&paras(&back)[0].objects[0], InlineObject::Image { ole: Some(_), .. }));
    assert_eq!(spin(&paras(&back)[0].objects[0]), craft_wordmodel::geom::Spin::new(45.0, false, true));

    // DrawingML: the picture's `a:xfrm` and the drawing's effect extent follow the turn.
    let dml = r##"<w:p><w:r><w:object w:dxaOrig="1440" w:dyaOrig="720"><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="914400" cy="457200"/><wp:docPr id="7" name="Object 7"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name=""/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="rId8"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm flipH="1"><a:off x="0" y="0"/><a:ext cx="914400" cy="457200"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing><o:OLEObject Type="Embed" ProgID="Package" DrawAspect="Content" ObjectID="_1000000002" r:id="rId9"/></w:object></w:r></w:p>"##;
    let mut d = craft_docx::read(&docx(dml, &doc_rels, &parts)).unwrap();
    assert_eq!(spin(&paras(&d)[0].objects[0]), craft_wordmodel::geom::Spin::new(0.0, true, false));
    if let Some(f) = first_object(&mut d).float_mut() {
        f.set_spin(craft_wordmodel::geom::Spin::new(90.0, true, false));
    }
    let out = craft_docx::write(&d).unwrap();
    let body = text(&unzip(&out), "word/document.xml");
    assert_eq!(attr_values(&body, "a:xfrm", "rot"), ["5400000"]);
    assert_eq!(attr_values(&body, "a:xfrm", "flipH"), ["1"]);
    // 72 × 36 pt turned 90°: 18 pt narrower each side, 18 pt taller each side.
    assert_eq!(attr_values(&body, "wp:effectExtent", "l"), ["-228600"]);
    assert_eq!(attr_values(&body, "wp:effectExtent", "t"), ["228600"]);
    let back = craft_docx::read(&out).unwrap();
    let o = &paras(&back)[0].objects[0];
    assert!(matches!(o, InlineObject::Image { ole: Some(_), .. }), "{o:?}");
    assert_eq!(spin(o), craft_wordmodel::geom::Spin::new(90.0, true, false));
    assert_eq!(o.frame().unwrap().2.effect, [0.0; 4], "the rotated overhang is not kept as effects room");
}

/// Issue #41: tracked formatting changes (ECMA-376 §17.13.5) survive open and save — run,
/// paragraph mark, paragraph, numbering, table, row, cell and section — each written last in
/// its parent, holding the properties before the change.
#[test]
fn formatting_revisions_round_trip() {
    let body = r#"
<w:p><w:r><w:t xml:space="preserve">Plain, </w:t></w:r><w:r><w:rPr><w:b/><w:rPrChange w:id="5" w:author="Alice" w:date="2026-10-01T00:00:00Z"><w:rPr/></w:rPrChange></w:rPr><w:t>bold by Alice</w:t></w:r><w:r><w:rPr><w:sz w:val="28"/><w:rPrChange w:id="99999999999" w:author="Bob"><w:rPr><w:i/><w:sz w:val="24"/><w:rPrChange w:id="1" w:author="Nested"><w:rPr/></w:rPrChange></w:rPr></w:rPrChange></w:rPr><w:t xml:space="preserve"> end.</w:t></w:r></w:p>
<w:p><w:pPr><w:numPr><w:ilvl w:val="0"/><w:numId w:val="1"/><w:numberingChange w:id="6" w:author="Alice" w:date="2026-10-01T00:00:00Z" w:original="1."/></w:numPr><w:jc w:val="center"/><w:rPr><w:i/><w:rPrChange w:id="7" w:author="Alice" w:date="2026-10-01T00:00:00Z"><w:rPr/></w:rPrChange></w:rPr><w:pPrChange w:id="8" w:author="Alice" w:date="2026-10-01T00:00:00Z"><w:pPr><w:ind w:left="720"/></w:pPr></w:pPrChange></w:pPr><w:r><w:t>Centred</w:t></w:r></w:p>
<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/><w:jc w:val="center"/><w:tblPrChange w:id="9" w:author="Bob"><w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr></w:tblPrChange></w:tblPr><w:tblGrid><w:gridCol w:w="2000"/></w:tblGrid>
<w:tr><w:trPr><w:cantSplit/><w:trPrChange w:id="10" w:author="Bob"><w:trPr/></w:trPrChange></w:trPr><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/><w:shd w:val="clear" w:color="auto" w:fill="FFFF00"/><w:tcPrChange w:id="11" w:author="Bob"><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr></w:tcPrChange></w:tcPr><w:p><w:r><w:t>cell</w:t></w:r></w:p></w:tc></w:tr></w:tbl>
<w:p/>
<w:sectPr><w:pgSz w:w="15840" w:h="12240" w:orient="landscape"/><w:sectPrChange w:id="12" w:author="Carol" w:date="2026-10-02T00:00:00Z"><w:sectPr><w:pgSz w:w="12240" w:h="15840"/></w:sectPr></w:sectPrChange></w:sectPr>"#;
    let d = read_body(body);
    let rev = |i: u32| d.revisions.get(i as usize).map(|r| (r.kind, r.author.as_str(), r.date.as_str()));
    let p = paras(&d);
    let runs: Vec<_> = p[0].run_ranges().map(|(r, c)| (r, c.clone())).collect();
    assert_eq!(runs.len(), 3);
    let alice = runs[1].1.fmt_change.as_deref().expect("Alice's rPrChange");
    assert_eq!(rev(alice.rev), Some((craft_wordmodel::RevisionKind::Format, "Alice", "2026-10-01T00:00:00Z")));
    assert_eq!((runs[1].1.bold, alice.old.bold), (Some(true), None));
    let bob = runs[2].1.fmt_change.as_deref().expect("Bob's rPrChange");
    assert_eq!((bob.old.italic, bob.old.size, bob.old.fmt_change.is_none()), (Some(true), Some(12.0), true), "a nested change is dropped");
    assert!(runs[0].1.fmt_change.is_none());
    let pc = p[1].props.fmt_change.as_deref().expect("pPrChange");
    assert_eq!((p[1].props.align, pc.old.align, pc.old.indent_left), (Some(Align::Center), None, Some(36.0)));
    assert_eq!(p[1].props.num_change.as_deref().map(|n| n.original.as_str()), Some("1."));
    assert!(p[1].mark.fmt_change.is_some());
    let Some(Block::Table(t)) = d.body.get(2).map(|b| &**b) else { panic!("table") };
    assert_eq!(t.props.fmt_change.as_deref().map(|c| c.old.align), Some(None));
    assert_eq!(t.rows[0].props.fmt_change.as_deref().map(|c| c.old.cant_split), Some(false));
    assert_eq!(t.rows[0].cells[0].props.fmt_change.as_deref().map(|c| c.old.shading), Some(None));
    let sc = d.last_section.fmt_change.as_deref().expect("sectPrChange");
    assert_eq!((d.last_section.landscape, sc.old.landscape), (true, false));
    assert_eq!(rev(sc.rev).map(|r| r.1), Some("Carol"));

    // Written back: each change is the last child of its parent, and reads back the same.
    let bytes = craft_docx::write(&d).unwrap();
    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
    let mut xml = String::new();
    std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
    for (tag, parent) in [
        ("w:rPrChange", "</w:rPr></w:rPrChange></w:rPr>"),
        ("w:pPrChange", "</w:pPr></w:pPrChange></w:pPr>"),
        ("w:tblPrChange", "</w:tblPr></w:tblPrChange></w:tblPr>"),
        ("w:trPrChange", "</w:trPrChange></w:trPr>"),
        ("w:tcPrChange", "</w:tcPr></w:tcPrChange></w:tcPr>"),
        ("w:sectPrChange", "</w:sectPr></w:sectPrChange></w:sectPr>"),
    ] {
        assert!(xml.contains(&format!("<{tag} w:id=")), "{tag}: {xml}");
        assert!(xml.contains(parent), "{tag} last: {xml}");
    }
    assert!(xml.contains(r#"<w:numberingChange w:id="#) && xml.contains(r#"w:original="1."/></w:numPr>"#), "{xml}");
    assert!(xml.contains(r#"<w:b/><w:rPrChange w:id="#), "{xml}");
    assert!(!xml.contains("<w:bCs"), "Saving must not add an absent complex-script bold: {xml}");
    let again = craft_docx::read(&bytes).unwrap();
    assert_eq!(again.body, d.body);
    assert_eq!(again.last_section, d.last_section);
    assert_eq!(again.revisions, d.revisions);
}

/// A package with `styles`, a theme (accent1 4472C4, accent2 ED7D31, major font "Major Face") and,
/// when given, `settings`.
fn themed_docx(body: &str, styles: &str, settings: Option<&str>) -> Document {
    let theme = r#"<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="T"><a:themeElements><a:clrScheme name="T"><a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1><a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1><a:dk2><a:srgbClr val="44546A"/></a:dk2><a:lt2><a:srgbClr val="E7E6E6"/></a:lt2><a:accent1><a:srgbClr val="4472C4"/></a:accent1><a:accent2><a:srgbClr val="ED7D31"/></a:accent2><a:accent3><a:srgbClr val="A5A5A5"/></a:accent3><a:accent4><a:srgbClr val="FFC000"/></a:accent4><a:accent5><a:srgbClr val="5B9BD5"/></a:accent5><a:accent6><a:srgbClr val="70AD47"/></a:accent6><a:hlink><a:srgbClr val="0563C1"/></a:hlink><a:folHlink><a:srgbClr val="954F72"/></a:folHlink></a:clrScheme><a:fontScheme name="T"><a:majorFont><a:latin typeface="Major Face"/></a:majorFont><a:minorFont><a:latin typeface="Minor Face"/></a:minorFont></a:fontScheme></a:themeElements></a:theme>"#;
    let styles = format!(
        r#"<w:styles {W_NS}><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>{styles}</w:styles>"#
    );
    let mut doc_rels = vec![("rId1", "styles", "styles.xml"), ("rId2", "theme", "theme/theme1.xml")];
    let mut extra = vec![("word/styles.xml", styles.as_str()), ("word/theme/theme1.xml", theme)];
    let settings = settings.map(|s| format!(r#"<w:settings {W_NS}>{s}</w:settings>"#));
    if let Some(s) = &settings {
        doc_rels.push(("rId3", "settings", "settings.xml"));
        extra.push(("word/settings.xml", s.as_str()));
    }
    craft_docx::read(&docx(body, &doc_rels, &extra)).unwrap()
}

/// Within one step per channel: Word's tint and shade round differently from ours in the last bit.
fn near(c: Option<TextColor>, want: Rgb) -> bool {
    matches!(c, Some(TextColor::Rgb(Rgb(r, g, b))) if r.abs_diff(want.0) <= 1 && g.abs_diff(want.1) <= 1 && b.abs_diff(want.2) <= 1)
}

#[test]
fn theme_colour_wins_over_the_fixed_colour() {
    // Heading 1 as Word writes it: the stale w:val is ignored, accent1 darkened 25% is 2F5496.
    let styles = r#"<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:rPr><w:color w:val="FF0000" w:themeColor="accent1" w:themeShade="BF"/><w:u w:val="single" w:color="FF0000" w:themeColor="accent2"/></w:rPr></w:style>"#;
    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>H</w:t></w:r></w:p>
<w:p><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeTint="99"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeTint="66"/></w:rPr><w:t>b</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeTint="33"/></w:rPr><w:t>c</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeShade="7F"/></w:rPr><w:t>d</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent2" w:themeShade="BF"/></w:rPr><w:t>e</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="text2"/></w:rPr><w:t>f</w:t></w:r><w:r><w:rPr><w:color w:val="auto" w:themeColor="hyperlink"/></w:rPr><w:t>g</w:t></w:r><w:r><w:rPr><w:shd w:val="clear" w:color="auto" w:fill="000000" w:themeFill="accent2" w:themeFillTint="33"/></w:rPr><w:t>h</w:t></w:r></w:p>"#;
    let d = themed_docx(body, styles, None);
    let h = d.styles.get("Heading1").unwrap();
    assert_eq!(h.chr.color, Some(TextColor::Rgb(Rgb(0x2F, 0x54, 0x96))));
    assert_eq!(h.chr.underline_color, Some(Rgb(0xED, 0x7D, 0x31)));
    let p = paras(&d);
    let at = |i: usize| p[1].props_of_char(i);
    // Colours Word writes into w:val next to these theme colours (Grid Table and heading styles).
    assert!(near(at(0).color, Rgb(0x8E, 0xAA, 0xDB)), "{:?}", at(0).color);
    assert!(near(at(1).color, Rgb(0xB4, 0xC6, 0xE7)), "{:?}", at(1).color);
    assert!(near(at(2).color, Rgb(0xD9, 0xE2, 0xF3)), "{:?}", at(2).color);
    assert!(near(at(3).color, Rgb(0x1F, 0x37, 0x63)), "{:?}", at(3).color);
    assert!(near(at(4).color, Rgb(0xC4, 0x59, 0x11)), "{:?}", at(4).color);
    // text2 maps to dk2 without a w:clrSchemeMapping; hyperlink to hlink.
    assert_eq!(at(5).color, Some(TextColor::Rgb(Rgb(0x44, 0x54, 0x6A))));
    assert_eq!(at(6).color, Some(TextColor::Rgb(Rgb(0x05, 0x63, 0xC1))));
    let fill = at(7).shading.unwrap();
    assert!(near(Some(TextColor::Rgb(fill)), Rgb(0xFB, 0xE4, 0xD5)), "{fill:?}");
}

/// `w:shd w:val="nil"` paints nothing despite its fill: a CV template's red cell showed over the name.
#[test]
fn nil_shading_paints_no_fill() {
    let body = r#"
<w:tbl><w:tblGrid><w:gridCol w:w="200"/><w:gridCol w:w="2000"/></w:tblGrid><w:tr>
 <w:tc><w:tcPr><w:shd w:val="nil" w:color="auto" w:fill="C00000"/></w:tcPr><w:p/></w:tc>
 <w:tc><w:tcPr><w:shd w:val="clear" w:color="auto" w:fill="C00000"/></w:tcPr><w:p/></w:tc></w:tr></w:tbl>
<w:p><w:pPr><w:shd w:val="nil" w:fill="C00000" w:themeFill="accent2"/></w:pPr><w:r><w:rPr><w:shd w:val="nil" w:color="C00000" w:fill="C00000"/></w:rPr><w:t>x</w:t></w:r></w:p>"#;
    let d = read_body(body);
    let Block::Table(t) = &*d.body[0] else { panic!("table first") };
    assert_eq!(t.rows[0].cells[0].props.shading, None);
    assert_eq!(t.rows[0].cells[1].props.shading, Some(Rgb(0xC0, 0, 0)));
    let p = paras(&d);
    assert_eq!(p[0].props.shading, None);
    assert_eq!(p[0].props_of_char(0).shading, None);
}

/// A border's theme colour wins over its stale `w:color`: a template's white rule showed as black.
#[test]
fn border_theme_colour_wins_over_the_fixed_colour() {
    let body = r#"
<w:p><w:pPr><w:pBdr><w:top w:val="single" w:sz="4" w:color="000000" w:themeColor="background1"/><w:left w:val="single" w:sz="4" w:color="FF0000"/></w:pBdr></w:pPr><w:r><w:rPr><w:bdr w:val="single" w:sz="4" w:color="auto" w:themeColor="accent2"/></w:rPr><w:t>x</w:t></w:r></w:p>
<w:tbl><w:tblPr><w:tblBorders><w:top w:val="single" w:sz="4" w:color="000000" w:themeColor="accent1"/></w:tblBorders></w:tblPr><w:tblGrid><w:gridCol w:w="2000"/></w:tblGrid><w:tr><w:tc><w:tcPr><w:tcBorders><w:left w:val="single" w:sz="4" w:color="000000" w:themeColor="accent6" w:themeShade="BF"/></w:tcBorders></w:tcPr><w:p/></w:tc></w:tr></w:tbl>
<w:p/>
<w:sectPr><w:pgBorders><w:top w:val="single" w:sz="4" w:color="000000" w:themeColor="text2"/></w:pgBorders></w:sectPr>"#;
    let styles = r#"<w:style w:type="table" w:styleId="T"><w:name w:val="T"/><w:tblPr><w:tblBorders><w:bottom w:val="single" w:sz="4" w:color="000000" w:themeColor="accent3"/></w:tblBorders></w:tblPr></w:style>"#;
    let d = themed_docx(body, styles, None);
    let p = paras(&d);
    let pb = p[0].props.borders.unwrap();
    assert_eq!(pb.top.and_then(|b| b.color), Some(Rgb(0xFF, 0xFF, 0xFF)));
    assert_eq!(pb.left.and_then(|b| b.color), Some(Rgb(0xFF, 0, 0)), "no theme colour keeps the fixed one");
    assert_eq!(p[0].props_of_char(0).border.and_then(|b| b.color), Some(Rgb(0xED, 0x7D, 0x31)));
    let Block::Table(t) = &*d.body[1] else { panic!("table second") };
    assert_eq!(t.props.borders.and_then(|b| b.top).and_then(|b| b.color), Some(Rgb(0x44, 0x72, 0xC4)));
    let cell = t.rows[0].cells[0].props.borders.and_then(|b| b.left).and_then(|b| b.color);
    assert!(near(cell.map(TextColor::Rgb), Rgb(0x53, 0x81, 0x35)), "{cell:?}");
    assert_eq!(d.last_section.page_borders.and_then(|b| b.top).and_then(|b| b.color), Some(Rgb(0x44, 0x54, 0x6A)));
    let st = d.styles.get("T").and_then(|s| s.table.as_ref()).and_then(|t| t.borders);
    assert_eq!(st.and_then(|b| b.bottom).and_then(|b| b.color), Some(Rgb(0xA5, 0xA5, 0xA5)));
}

/// Given both `themeTint` and `themeShade`, Word applies the tint alone, for text colours,
/// shading and borders (MS-OI29500 17.3.2.6 b, 17.4.32 a; MS-OE376 2.3.2.3 a).
#[test]
fn theme_tint_wins_over_theme_shade() {
    let both = r#"w:themeColor="accent1" w:themeTint="99" w:themeShade="7F""#;
    let body = format!(
        r#"<w:p><w:pPr><w:pBdr><w:top w:val="single" w:sz="4" w:color="000000" {both}/></w:pBdr></w:pPr><w:r><w:rPr><w:color w:val="000000" {both}/><w:bdr w:val="single" w:sz="4" w:color="000000" {both}/><w:shd w:val="clear" w:color="auto" w:fill="000000" w:themeFill="accent1" w:themeFillTint="99" w:themeFillShade="7F"/></w:rPr><w:t>a</w:t></w:r></w:p>"#
    );
    let d = themed_docx(&body, "", None);
    let p = paras(&d);
    let ch = p[0].props_of_char(0);
    // accent1 4472C4 lightened by tint 99 alone, as Word writes it into w:val.
    let tinted = Rgb(0x8E, 0xAA, 0xDB);
    assert!(near(ch.color, tinted), "text colour {:?}", ch.color);
    let run_border = ch.border.and_then(|b| b.color).map(TextColor::Rgb);
    assert!(near(run_border, tinted), "text border {run_border:?}");
    let para_border = p[0].props.borders.and_then(|b| b.top).and_then(|b| b.color).map(TextColor::Rgb);
    assert!(near(para_border, tinted), "paragraph border {para_border:?}");
    assert!(near(ch.shading.map(TextColor::Rgb), tinted), "shading {:?}", ch.shading);
}

#[test]
fn theme_colours_follow_the_colour_scheme_mapping() {
    // Styles are read before settings; the mapping still applies to them.
    let styles =
        r#"<w:style w:type="character" w:styleId="T1"><w:name w:val="T1"/><w:rPr><w:color w:val="000000" w:themeColor="text1"/></w:rPr></w:style>"#;
    let body = r#"<w:p><w:r><w:rPr><w:rStyle w:val="T1"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="background1"/></w:rPr><w:t>b</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="dark1"/></w:rPr><w:t>c</w:t></w:r></w:p>"#;
    let mapping = r#"<w:clrSchemeMapping w:bg1="dark1" w:t1="accent2" w:bg2="light2" w:t2="dark2" w:accent1="accent1" w:accent2="accent2" w:accent3="accent3" w:accent4="accent4" w:accent5="accent5" w:accent6="accent6" w:hyperlink="hyperlink" w:followedHyperlink="followedHyperlink"/>"#;
    let d = themed_docx(body, styles, Some(mapping));
    assert_eq!(d.styles.get("T1").unwrap().chr.color, Some(TextColor::Rgb(Rgb(0xED, 0x7D, 0x31))));
    let p = paras(&d);
    assert_eq!(p[0].props_of_char(1).color, Some(TextColor::Rgb(Rgb(0, 0, 0))), "background1 → dark1");
    assert_eq!(p[0].props_of_char(2).color, Some(TextColor::Rgb(Rgb(0, 0, 0))), "dark1 isn't remapped");
}

#[test]
fn theme_colour_without_a_theme_keeps_the_fixed_colour() {
    let d = read_body(r#"<w:p><w:r><w:rPr><w:color w:val="00FF00" w:themeColor="accent1" w:themeShade="BF"/></w:rPr><w:t>a</w:t></w:r></w:p>"#);
    assert_eq!(paras(&d)[0].props_of_char(0).color, Some(TextColor::Rgb(Rgb(0, 0xFF, 0))));
}

#[test]
fn underline_without_a_val_draws_no_underline() {
    // w:val has no schema default (ECMA-376 CT_Underline); Word leaves a bare w:u with a colour plain.
    let d = read_body(
        r#"<w:p><w:r><w:rPr><w:u w:val="single"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:u w:color="FF0000"/></w:rPr><w:t>b</w:t></w:r><w:r><w:t>c</w:t></w:r></w:p>"#,
    );
    let p = paras(&d);
    assert_eq!(p[0].props_of_char(0).underline, Some(Underline::Single));
    let b = p[0].props_of_char(1);
    assert_eq!(b.underline, None);
    assert_eq!(b.underline_color, Some(Rgb(0xFF, 0, 0)), "the colour is still read");
    assert_eq!(p[0].props_of_char(2).underline, None);
    let back = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    let b = paras(&back)[0].props_of_char(1);
    assert_eq!((b.underline, b.underline_color), (None, Some(Rgb(0xFF, 0, 0))), "saving keeps the colour, not an underline");
}

#[test]
fn theme_font_wins_over_the_fixed_font() {
    let styles = r#"<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:rPr><w:rFonts w:ascii="Calibri Light" w:hAnsi="Calibri Light" w:asciiTheme="majorHAnsi" w:hAnsiTheme="majorHAnsi"/></w:rPr></w:style>"#;
    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>H</w:t></w:r></w:p>
<w:p><w:r><w:rPr><w:rFonts w:hAnsi="Arial" w:hAnsiTheme="minorHAnsi"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:rFonts w:ascii="Arial" w:asciiTheme="minorHAnsi"/></w:rPr><w:t>b</w:t></w:r><w:r><w:rPr><w:rFonts w:ascii="Arial" w:hAnsiTheme="majorHAnsi"/></w:rPr><w:t>c</w:t></w:r></w:p>"#;
    let d = themed_docx(body, styles, None);
    assert_eq!(d.styles.get("Heading1").unwrap().chr.font.as_deref(), Some("Major Face"));
    let p = paras(&d);
    assert_eq!(p[1].props_of_char(0).font.as_deref(), Some("Minor Face"));
    assert_eq!(p[1].props_of_char(1).font.as_deref(), Some("Minor Face"));
    // An explicit ascii font still beats a theme font given only for hAnsi.
    assert_eq!(p[1].props_of_char(2).font.as_deref(), Some("Arial"));
}

/// Issue #400: moved text (ECMA-376 §17.13.5.21–28). `w:moveFrom` / `w:moveTo` inside named
/// move ranges are the two ends of one move, paragraph marks included; the ranges are written
/// back around them. A move missing an end, or whose range never ends, is a plain deletion and
/// insertion.
#[test]
fn move_revisions_round_trip() {
    let body = r#"
<w:p><w:pPr><w:rPr><w:moveTo w:id="1" w:author="Ana" w:date="2026-10-03T00:00:00Z"/></w:rPr></w:pPr><w:moveToRangeStart w:id="2" w:name="move1" w:author="Ana" w:date="2026-10-03T00:00:00Z"/><w:moveTo w:id="3" w:author="Ana" w:date="2026-10-03T00:00:00Z"><w:r><w:t>Moved here.</w:t></w:r></w:moveTo></w:p>
<w:moveToRangeEnd w:id="2"/>
<w:p><w:r><w:t xml:space="preserve">Stays. </w:t></w:r><w:moveFromRangeStart w:id="4" w:name="move1" w:author="Ana" w:date="2026-10-03T00:00:00Z"/><w:moveFrom w:id="5" w:author="Ana" w:date="2026-10-03T00:00:00Z"><w:r><w:t>Moved here.</w:t></w:r></w:moveFrom><w:moveFromRangeEnd w:id="4"/></w:p>
<w:p><w:moveFromRangeStart w:id="6" w:name="lonely" w:author="Bo"/><w:moveFrom w:id="7" w:author="Bo"><w:r><w:t>No destination</w:t></w:r></w:moveFrom><w:moveFromRangeEnd w:id="6"/><w:moveToRangeStart w:id="8" w:name="open" w:author="Bo"/><w:moveTo w:id="9" w:author="Bo"><w:r><w:t>never ends</w:t></w:r></w:moveTo><w:moveTo w:id="10" w:author="Cy"><w:r><w:t>no range</w:t></w:r></w:moveTo><w:moveFromRangeEnd w:id="404"/></w:p>"#;
    let check = |d: &Document| {
        let p = paras(d);
        let name = |r: Option<u32>| d.move_name(r).map(str::to_string);
        assert_eq!(name(p[0].mark.ins).as_deref(), Some("move1"), "a moved paragraph mark");
        let to = p[0].runs[0].props.ins;
        assert_eq!((name(to).as_deref(), d.revisions[to.unwrap() as usize].kind), (Some("move1"), RevisionKind::Insert));
        let from = p[1].run_ranges().find(|(_, c)| c.del.is_some()).map(|(_, c)| c.del).unwrap();
        assert_eq!((name(from).as_deref(), d.revisions[from.unwrap() as usize].kind), (Some("move1"), RevisionKind::Delete));
        assert_eq!(d.revisions[from.unwrap() as usize].author, "Ana");
        // Hostile ends: each is a plain revision, still tracked.
        for (r, c) in p[2].run_ranges() {
            assert!(c.ins.or(c.del).is_some(), "{r:?} keeps its revision");
            assert_eq!(name(c.ins.or(c.del)), None, "{r:?} is no move");
        }
    };
    let d = read_body(body);
    check(&d);
    let out = craft_docx::write(&d).unwrap();
    let xml = text(&unzip(&out), "word/document.xml");
    assert_eq!(attr_values(&xml, "w:moveFromRangeStart", "w:name"), ["move1"]);
    assert_eq!(attr_values(&xml, "w:moveToRangeStart", "w:name"), ["move1"]);
    assert_eq!(attr_values(&xml, "w:moveToRangeStart", "w:author"), ["Ana"]);
    assert_eq!(attr_values(&xml, "w:moveToRangeStart", "w:id"), attr_values(&xml, "w:moveToRangeEnd", "w:id"));
    assert_eq!(attr_values(&xml, "w:moveFromRangeStart", "w:id"), attr_values(&xml, "w:moveFromRangeEnd", "w:id"));
    assert!(xml.contains("<w:moveFrom ") && !xml.contains("<w:delText xml:space=\"preserve\">Moved"), "moved-away text stays in w:t");
    // The range around the moved paragraph includes its mark: it ends in the next paragraph.
    let to_start = xml.find("<w:moveToRangeStart").unwrap();
    let to_end = xml.find("<w:moveToRangeEnd").unwrap();
    assert!(xml[to_start..to_end].contains("</w:p>"), "{xml}");
    check(&craft_docx::read(&out).unwrap());
}

/// A document's own footnote separators and continuation notice are kept (ECMA-376 §17.11), and
/// written back as Word numbers them: -1, 0 and 1, the notes after them.
#[test]
fn note_separators_and_continuation_notice_round_trip() {
    let footnotes = format!(
        r#"<w:footnotes {W_NS}><w:footnote w:type="separator" w:id="-1"><w:p><w:pPr><w:spacing w:after="0"/></w:pPr><w:r><w:separator/></w:r></w:p></w:footnote><w:footnote w:type="continuationSeparator" w:id="0"><w:p><w:r><w:t xml:space="preserve">More: </w:t></w:r><w:r><w:continuationSeparator/></w:r></w:p></w:footnote><w:footnote w:type="continuationNotice" w:id="1"><w:p><w:pPr><w:jc w:val="right"/></w:pPr><w:r><w:t>(continued)</w:t></w:r></w:p></w:footnote><w:footnote w:id="2"><w:p><w:r><w:footnoteRef/></w:r><w:r><w:t xml:space="preserve"> The note.</w:t></w:r></w:p></w:footnote></w:footnotes>"#
    );
    let body = r#"<w:p><w:r><w:t>Text</w:t></w:r><w:r><w:footnoteReference w:id="2"/></w:r></w:p>"#;
    let bytes = docx(body, &[("rId1", "footnotes", "footnotes.xml")], &[("word/footnotes.xml", &footnotes)]);
    let check = |d: &Document| {
        let s = &d.footnote_separators;
        let first = |b: &Option<craft_wordmodel::Blocks>| b.as_ref().unwrap()[0].as_para().unwrap().clone();
        let sep = first(&s.separator);
        assert_eq!(sep.objects.iter().map(InlineObject::as_note_separator).collect::<Vec<_>>(), vec![Some(false)]);
        assert_eq!(sep.props.space_after, Some(0.0));
        let cont = first(&s.continuation_separator);
        assert_eq!(cont.plain_text(), "More: ");
        assert_eq!(cont.objects.iter().map(InlineObject::as_note_separator).collect::<Vec<_>>(), vec![Some(true)]);
        let notice = first(&s.continuation_notice);
        assert_eq!(notice.plain_text(), "(continued)");
        assert_eq!(notice.props.align, Some(Align::Right));
        assert!(d.endnote_separators.is_empty());
        // The note itself is read as before.
        let InlineObject::NoteRef { id, .. } = paras(d)[0].objects[0] else { panic!() };
        assert_eq!(d.parts[&id].blocks[0].as_para().unwrap().plain_text(), " The note.");
        assert_eq!(d.parts.len(), 1, "special notes aren't notes");
    };
    let d = craft_docx::read(&bytes).unwrap();
    check(&d);

    let out = craft_docx::write(&d).unwrap();
    let part = |name: &str| {
        let mut z = zip::ZipArchive::new(std::io::Cursor::new(&out)).unwrap();
        let mut xml = String::new();
        std::io::Read::read_to_string(&mut z.by_name(name).unwrap(), &mut xml).unwrap();
        xml
    };
    let notes = part("word/footnotes.xml");
    for (kind, id) in [("separator", "-1"), ("continuationSeparator", "0"), ("continuationNotice", "1")] {
        assert!(notes.contains(&format!(r#"<w:footnote w:type="{kind}" w:id="{id}">"#)), "{kind}: {notes}");
    }
    assert!(notes.contains(r#"<w:footnote w:id="2">"#), "the note follows the notice: {notes}");
    assert!(part("word/document.xml").contains(r#"<w:footnoteReference w:id="2"/>"#));
    let settings = part("word/settings.xml");
    assert!(settings.contains(r#"<w:footnote w:id="-1"/><w:footnote w:id="0"/><w:footnote w:id="1"/>"#), "{settings}");
    check(&craft_docx::read(&out).unwrap());
}

/// Issue #534: East Asian number formats are read, labelled and written back as they were; a
/// value the format doesn't define is decimal, and a level without `w:ind` has no indent.
#[test]
fn east_asian_number_formats_read_label_and_round_trip() {
    use craft_wordmodel::numbering::Counters;
    use craft_wordmodel::section::NumFormat;
    let lvl = |i: u8, fmt: &str, text: &str| {
        format!(r#"<w:lvl w:ilvl="{i}"><w:start w:val="1"/><w:numFmt w:val="{fmt}"/><w:suff w:val="nothing"/><w:lvlText w:val="{text}"/></w:lvl>"#)
    };
    let levels = [
        lvl(0, "chineseCounting", "%1、"),
        lvl(1, "chineseCountingThousand", "第%2章"),
        lvl(2, "japaneseLegal", "（%3）"),
        lvl(3, "decimalEnclosedCircle", "%4"),
        lvl(4, "hebrew1", "%5."),
        lvl(5, "notAFormat", "%6."),
    ]
    .concat();
    let numbering = format!(
        r#"<w:numbering {W_NS}><w:abstractNum w:abstractNumId="0">{levels}</w:abstractNum><w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num></w:numbering>"#
    );
    let item = |lv: u8| format!(r#"<w:p><w:pPr><w:numPr><w:ilvl w:val="{lv}"/><w:numId w:val="1"/></w:numPr></w:pPr><w:r><w:t>x</w:t></w:r></w:p>"#);
    let body: String = [0, 0, 0, 1, 2, 3, 4, 5].map(item).concat();
    let bytes = docx(&body, &[("rId1", "numbering", "numbering.xml")], &[("word/numbering.xml", &numbering)]);
    let d = craft_docx::read(&bytes).unwrap();
    let formats = |d: &Document| (0..6).map(|i| d.numbering.level(1, i).map(|l| l.format)).collect::<Vec<_>>();
    let want = [
        NumFormat::ChineseCounting,
        NumFormat::ChineseCountingThousand,
        NumFormat::JapaneseLegal,
        NumFormat::DecimalEnclosedCircle,
        NumFormat::Hebrew1,
        NumFormat::Decimal,
    ]
    .map(Some);
    assert_eq!(formats(&d), want);
    assert_eq!(d.numbering.level(1, 0).map(|l| (l.indent, l.hanging)), Some((0.0, 0.0)));
    let mut c = Counters::default();
    let labels: Vec<String> =
        paras(&d).iter().filter_map(|p| p.props.numbering).filter_map(|n| c.next_label(&d.numbering, n.num, n.level)).map(|l| l.0).collect();
    assert_eq!(labels, ["一、", "二、", "三、", "第一章", "（壱）", "①", "1.", "1."]);
    // Saved and read again, every format is the one the file had (hebrew1 too, which shows as
    // decimal for now).
    let out = craft_docx::write(&d).unwrap();
    let back = craft_docx::read(&out).unwrap();
    assert_eq!(formats(&back), want);
}

/// #4985: a level with numFmt none and literal text (`RESPONSE:`) labels its paragraph with that
/// text, as in Word, and keeps both through a save.
#[test]
fn a_none_level_s_literal_text_is_its_label() {
    use craft_wordmodel::numbering::Counters;
    use craft_wordmodel::section::NumFormat;
    let numbering = format!(
        r#"<w:numbering {W_NS}><w:abstractNum w:abstractNumId="0"><w:lvl w:ilvl="0"><w:start w:val="1"/><w:numFmt w:val="none"/><w:lvlText w:val="RESPONSE:"/><w:pPr><w:ind w:left="1440" w:hanging="1440"/></w:pPr></w:lvl></w:abstractNum><w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num></w:numbering>"#
    );
    let body = r#"<w:p><w:pPr><w:numPr><w:ilvl w:val="0"/><w:numId w:val="1"/></w:numPr></w:pPr><w:r><w:t>X</w:t></w:r></w:p>"#;
    let bytes = docx(body, &[("rId1", "numbering", "numbering.xml")], &[("word/numbering.xml", &numbering)]);
    let label = |d: &Document| {
        let n = paras(d).first().and_then(|p| p.props.numbering)?;
        Counters::default().next_label(&d.numbering, n.num, n.level).map(|l| l.0)
    };
    let d = craft_docx::read(&bytes).unwrap();
    assert_eq!(label(&d).as_deref(), Some("RESPONSE:"));
    let back = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(
        back.numbering.level(1, 0).map(|l| (l.format, l.text.as_str(), l.indent, l.hanging)),
        Some((NumFormat::None, "RESPONSE:", 72.0, 72.0))
    );
    assert_eq!(label(&back).as_deref(), Some("RESPONSE:"));
}

/// #464: a bookmark whose end follows the document's final table keeps its end (it goes into
/// the table's last cell) and is saved as a matched pair.
#[test]
fn bookmark_around_final_table_keeps_its_end() {
    let body = r#"<w:bookmarkStart w:id="7" w:name="TableRange"/><w:tbl><w:tblPr/><w:tblGrid><w:gridCol w:w="1440"/></w:tblGrid><w:tr><w:tc><w:tcPr/><w:p><w:r><w:t>Cell</w:t></w:r></w:p></w:tc></w:tr></w:tbl><w:bookmarkEnd w:id="7"/><w:sectPr/>"#;
    let d = read_body(body);
    let marks = |d: &Document| {
        let Block::Table(t) = &*d.body[0] else { panic!("{:?}", d.body[0]) };
        t.rows[0].cells[0].blocks[0].as_para().unwrap().objects.clone()
    };
    let want = vec![InlineObject::BookmarkStart { name: "TableRange".into() }, InlineObject::BookmarkEnd { name: "TableRange".into() }];
    assert_eq!(marks(&d), want);
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(marks(&again), want);
    assert_eq!(again.bookmarks().len(), 1);
}

/// #465: a field whose cached result is an embedded picture (`INCLUDEPICTURE`, simple, complex or
/// locked) keeps the picture through reading and saving; the linked file is never read.
#[test]
fn includepicture_keeps_its_embedded_picture() {
    let png: &[u8] = b"\x89PNG\r\n\x1a\nstand-in";
    let pic = r#"<w:r><w:drawing><wp:inline><wp:extent cx="914400" cy="914400"/><wp:docPr id="1" name="P"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rIdPic"/></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#;
    let cases = [
        (format!(r#"<w:fldSimple w:instr="INCLUDEPICTURE &quot;picture.png&quot;">{pic}</w:fldSimple>"#), false),
        (format!(r#"<w:fldSimple w:instr="INCLUDEPICTURE &quot;picture.png&quot;" w:fldLock="1">{pic}</w:fldSimple>"#), true),
        (
            format!(
                r#"<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> INCLUDEPICTURE "picture.png" </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>{pic}<w:r><w:fldChar w:fldCharType="end"/></w:r>"#
            ),
            false,
        ),
    ];
    for (field, locked) in cases {
        let bytes = docx(&format!("<w:p>{field}</w:p><w:sectPr/>"), &[("rIdPic", "image", "media/picture.png")], &[]);
        let bytes = {
            // `docx` takes text parts; add the picture bytes as a binary part.
            let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
            let mut entries: Vec<(String, Vec<u8>)> = Vec::new();
            for i in 0..z.len() {
                let mut f = z.by_index(i).unwrap();
                let mut v = Vec::new();
                std::io::Read::read_to_end(&mut f, &mut v).unwrap();
                entries.push((f.name().unwrap().to_string(), v));
            }
            entries.push(("word/media/picture.png".into(), png.to_vec()));
            zip(&entries.iter().map(|(n, v)| (n.as_str(), v.as_slice())).collect::<Vec<_>>())
        };
        let check = |d: &Document| {
            let p = paras(d);
            let objs = &p[0].objects;
            assert_eq!(objs.len(), 3, "{objs:?}");
            assert_eq!(objs[0], InlineObject::FieldStart { instr: "INCLUDEPICTURE \"picture.png\"".into(), locked, dirty: false });
            let InlineObject::Image { media, .. } = &objs[1] else { panic!("{objs:?}") };
            assert_eq!(d.media.get(media).unwrap().as_slice(), png);
            assert_eq!(objs[2], InlineObject::FieldEnd);
        };
        let d = craft_docx::read(&bytes).unwrap();
        check(&d);
        check(&craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap());
    }
}

/// One anchored Word shape (`wps:wsp` inside `mc:AlternateContent`, as Word writes them) with
/// shape properties `sppr`, style `style` and extra `wsp` content.
fn anchored_wsp(name: &str, cx: u32, cy: u32, sppr: &str, style: &str, extra: &str) -> String {
    format!(
        r#"<w:r><mc:AlternateContent><mc:Choice Requires="wps"><w:drawing><wp:anchor distT="0" distB="0" distL="114300" distR="114300" simplePos="0" relativeHeight="1" behindDoc="0" locked="0" layoutInCell="1" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="column"><wp:posOffset>12700</wp:posOffset></wp:positionH><wp:positionV relativeFrom="paragraph"><wp:posOffset>25400</wp:posOffset></wp:positionV><wp:extent cx="{cx}" cy="{cy}"/><wp:effectExtent l="0" t="0" r="0" b="0"/><wp:wrapNone/><wp:docPr id="1" name="{name}"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp>{extra}<wps:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="{cx}" cy="{cy}"/></a:xfrm>{sppr}</wps:spPr>{style}<wps:bodyPr/></wps:wsp></a:graphicData></a:graphic></wp:anchor></w:drawing></mc:Choice><mc:Fallback><w:pict><v:line from="0,0" to="1pt,2pt"/></w:pict></mc:Fallback></mc:AlternateContent></w:r>"#
    )
}

/// #611: diagrams drawn with Word's shapes were mostly missing. Connectors and boxes take their
/// outline and fill from the theme through their style references, or name preset and scheme
/// colours; all of these are read, with line widths and arrowheads.
#[test]
fn theme_styled_connectors_and_callout_boxes_keep_their_paint() {
    let style = |ln: u8, fill: u8, clr: &str| {
        format!(
            r#"<wps:style><a:lnRef idx="{ln}"><a:schemeClr val="{clr}"/></a:lnRef><a:fillRef idx="{fill}"><a:schemeClr val="{clr}"/></a:fillRef><a:effectRef idx="0"><a:schemeClr val="{clr}"/></a:effectRef><a:fontRef idx="minor"><a:schemeClr val="tx1"/></a:fontRef></wps:style>"#
        )
    };
    let body = [
        // A connector with only a style: accent4, the theme's thinnest line, an arrowhead.
        anchored_wsp("Arrow", 673100, 889000, r#"<a:prstGeom prst="straightConnector1"><a:avLst/></a:prstGeom><a:ln><a:tailEnd type="triangle"/></a:ln>"#, &style(1, 0, "accent4"), "<wps:cNvCnPr/>"),
        // A callout text box: scheme fill, preset black outline.
        anchored_wsp(
            "Text Box",
            3073400,
            673100,
            r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:solidFill><a:schemeClr val="lt1"/></a:solidFill><a:ln w="6350"><a:solidFill><a:prstClr val="black"/></a:solidFill></a:ln>"#,
            "",
            r#"<wps:cNvSpPr txBox="1"/><wps:txbx><w:txbxContent><w:p><w:r><w:t>Callout</w:t></w:r></w:p></w:txbxContent></wps:txbx>"#,
        ),
        // A filled rectangle from its style alone.
        anchored_wsp("Rect", 292100, 647700, r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>"#, &style(2, 1, "accent1"), "<wps:cNvSpPr/>"),
        // An elbow connector.
        anchored_wsp("Elbow", 1270000, 635000, r#"<a:prstGeom prst="bentConnector3"><a:avLst/></a:prstGeom>"#, &style(1, 0, "accent2"), "<wps:cNvCnPr/>"),
        // A rounded-rectangle callout.
        anchored_wsp("Callout", 1270000, 635000, r#"<a:prstGeom prst="wedgeRoundRectCallout"><a:avLst/></a:prstGeom>"#, &style(2, 1, "accent1"), "<wps:cNvSpPr/>"),
    ]
    .concat();
    let d = read_body(&format!("<w:p>{body}</w:p>"));
    let theme = &d.settings.theme_colors;
    let objs = &paras(&d)[0].objects;
    assert_eq!(objs.len(), 5);
    let shape = |i: usize| match &objs[i] {
        InlineObject::Shape { kind, fill, stroke, stroke_width, extra, story, .. } => {
            (*kind, fill.as_ref().map(Fill::main_color), *stroke, *stroke_width, extra.arrow_end, story.is_some())
        }
        o => panic!("{o:?}"),
    };
    assert_eq!(shape(0), (ShapeKind::StraightConnector, None, Some(theme[7]), 0.5, true, false));
    assert_eq!(shape(1), (ShapeKind::TextBox, Some(theme[1]), Some(Rgb(0, 0, 0)), 0.5, false, true));
    assert_eq!(shape(2), (ShapeKind::Rectangle, Some(theme[4]), Some(theme[4]), 1.0, false, false));
    assert_eq!(shape(3), (ShapeKind::ElbowConnector, None, Some(theme[5]), 0.5, false, false));
    assert_eq!(shape(4).0, ShapeKind::RoundedRectangle);
    // The themed outline and the arrowhead survive saving.
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert!(matches!(&paras(&again)[0].objects[0], InlineObject::Shape { stroke, extra, .. } if *stroke == Some(theme[7]) && extra.arrow_end));
}

/// A rounded rectangle's corner is its `adj` (100000ths of the shorter side), read, capped and
/// written back; without one, and for presets only drawn as rounded rectangles, the default.
#[test]
fn rounded_rectangle_corners_are_read_and_saved() {
    let geom = |prst: &str, av: &str| {
        format!(r#"<a:prstGeom prst="{prst}"><a:avLst>{av}</a:avLst></a:prstGeom><a:solidFill><a:srgbClr val="D9D9D9"/></a:solidFill>"#)
    };
    let gd = |fmla: &str| format!(r#"<a:gd name="adj" fmla="{fmla}"/>"#);
    let body = [
        geom("roundRect", &gd("val 3565")),
        geom("roundRect", ""),
        geom("roundRect", &gd("val 90000")),
        geom("roundRect", &gd("val -20")),
        geom("roundRect", &gd("*/ 1 2 3")),
        geom("roundRect", r#"<a:gd name="adj1" fmla="val 100"/>"#),
        geom("wedgeRoundRectCallout", &gd("val 3565")),
    ]
    .iter()
    .map(|sppr| anchored_wsp("Rounded", 2540000, 1270000, sppr, "", "<wps:cNvSpPr/>"))
    .collect::<String>();
    let corners = |d: &Document| -> Vec<(ShapeKind, Option<u32>)> {
        paras(d)[0]
            .objects
            .iter()
            .filter_map(|o| match o {
                InlineObject::Shape { kind, extra, .. } => Some((*kind, extra.corner)),
                _ => None,
            })
            .collect()
    };
    let rounded = ShapeKind::RoundedRectangle;
    let expected =
        vec![(rounded, Some(3565)), (rounded, None), (rounded, Some(50_000)), (rounded, Some(0)), (rounded, None), (rounded, None), (rounded, None)];
    let d = read_body(&format!("<w:p>{body}</w:p>"));
    assert_eq!(corners(&d), expected);
    let bytes = craft_docx::write(&d).unwrap();
    let mut xml = String::new();
    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice())).unwrap();
    std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
    assert!(xml.contains(r#"<a:prstGeom prst="roundRect"><a:avLst><a:gd name="adj" fmla="val 3565"/></a:avLst></a:prstGeom>"#), "{xml}");
    assert_eq!(corners(&craft_docx::read(&bytes).unwrap()), expected);
}

/// #611: legacy VML lines and rectangles (documents without DrawingML).
#[test]
fn vml_lines_and_rectangles() {
    let body = r##"<w:p><w:r><w:pict><v:line style="position:absolute;flip:y;z-index:1" from="10pt,20pt" to="40pt,60pt" strokecolor="#4472c4 [3204]" strokeweight=".5pt"><v:stroke endarrow="block"/></v:line></w:pict></w:r>
<w:r><w:pict><v:rect style="position:absolute;margin-left:5pt;margin-top:6pt;width:30pt;height:20pt" fillcolor="#ff0000" stroked="f"/></w:pict></w:r></w:p>"##;
    let d = read_body(body);
    let objs = &paras(&d)[0].objects;
    assert_eq!(objs.len(), 2, "{objs:?}");
    match &objs[0] {
        InlineObject::Shape { kind: ShapeKind::Line, w, h, stroke, stroke_width, float, extra, .. } => {
            assert_eq!((*w, *h, *stroke, *stroke_width), (30.0, 40.0, Some(Rgb(0x44, 0x72, 0xC4)), 0.5));
            assert_eq!((float.x, float.y, float.flip_h, float.flip_v), (10.0, 20.0, false, true));
            assert!(extra.arrow_end && !extra.arrow_start);
        }
        o => panic!("{o:?}"),
    }
    assert!(matches!(
        &objs[1],
        InlineObject::Shape { kind: ShapeKind::Rectangle, fill: Some(Fill::Solid { color: Rgb(255, 0, 0), .. }), stroke: None, w: 30.0, h: 20.0, .. }
    ));
}

/// An arrowhead's kind, width and length (DrawingML `a:headEnd`/`a:tailEnd` `type`/`w`/`len`, VML
/// `startarrow`/`startarrowwidth`/`startarrowlength`) are read and saved: they set the size Word
/// draws it at. An end without `w`/`len` is medium.
#[test]
fn arrowheads_keep_their_kind_and_size() {
    use craft_wordmodel::connector::{ArrowKind, ArrowSize, ArrowStyle};
    let style = |kind, width, length| ArrowStyle { kind, width, length };
    let body = [
        anchored_wsp(
            "Line",
            1270000,
            0,
            r#"<a:prstGeom prst="line"><a:avLst/></a:prstGeom><a:ln w="12700"><a:solidFill><a:srgbClr val="000000"/></a:solidFill><a:headEnd type="stealth" w="sm" len="lg"/><a:tailEnd type="diamond" w="lg" len="sm"/></a:ln>"#,
            "",
            "<wps:cNvCnPr/>",
        ),
        anchored_wsp("Plain", 1270000, 0, r#"<a:prstGeom prst="line"><a:avLst/></a:prstGeom><a:ln><a:solidFill><a:srgbClr val="000000"/></a:solidFill><a:tailEnd type="triangle"/></a:ln>"#, "", "<wps:cNvCnPr/>"),
        r#"<w:r><w:pict><v:line style="position:absolute" from="10pt,20pt" to="40pt,20pt"><v:stroke startarrow="classic" startarrowwidth="narrow" startarrowlength="long" endarrow="oval" endarrowwidth="wide" endarrowlength="short"/></v:line></w:pict></w:r>"#.to_string(),
    ]
    .concat();
    let ends = |d: &Document| -> Vec<(bool, ArrowStyle, bool, ArrowStyle)> {
        paras(d)[0]
            .objects
            .iter()
            .map(|o| match o {
                InlineObject::Shape { extra, .. } => (extra.arrow_start, extra.start_style, extra.arrow_end, extra.end_style),
                o => panic!("{o:?}"),
            })
            .collect()
    };
    let expected = vec![
        (true, style(ArrowKind::Stealth, ArrowSize::Small, ArrowSize::Large), true, style(ArrowKind::Diamond, ArrowSize::Large, ArrowSize::Small)),
        (false, ArrowStyle::default(), true, ArrowStyle::default()),
        (true, style(ArrowKind::Stealth, ArrowSize::Small, ArrowSize::Large), true, style(ArrowKind::Oval, ArrowSize::Large, ArrowSize::Small)),
    ];
    let d = read_body(&format!("<w:p>{body}</w:p>"));
    assert_eq!(ends(&d), expected);
    let bytes = craft_docx::write(&d).unwrap();
    let mut xml = String::new();
    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice())).unwrap();
    std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
    assert!(xml.contains(r#"<a:headEnd type="stealth" w="sm" len="lg"/>"#), "{xml}");
    assert!(xml.contains(r#"<a:tailEnd type="diamond" w="lg" len="sm"/>"#), "{xml}");
    assert_eq!(ends(&craft_docx::read(&bytes).unwrap()), expected);
}

/// The right arrow's shapetype as Word writes it (ECMA-376 Part 4 `v:shapetype`, `o:spt` 13).
const VML_RIGHT_ARROW_TYPE: &str = r#"<v:shapetype id="_x0000_t13" coordsize="21600,21600" o:spt="13" adj="16200,5400" path="m@0,l@0@1,0@1,0@2@0@2@0,21600,21600,10800xe"><v:stroke joinstyle="miter"/><v:formulas><v:f eqn="val #0"/><v:f eqn="val #1"/></v:formulas><v:path o:connecttype="custom"/></v:shapetype>"#;

/// #1377: a VML shape drawn from a preset shapetype (`type="#_x0000_t13"`) is the DrawingML
/// preset WordCraft draws, with its fill, outline and size: from the shapetype beside it, from
/// Word's shapetype id when the shapetype was written at an earlier use, or from its own `o:spt`.
#[test]
fn vml_preset_shapes_are_drawn() {
    let pict = |inner: &str| format!("<w:p><w:r><w:pict>{inner}</w:pict></w:r></w:p>");
    let body = [
        pict(&format!(r##"{VML_RIGHT_ARROW_TYPE}<v:shape id="_x0000_i1026" type="#_x0000_t13" style="width:120pt;height:40pt" fillcolor="#ffa500"/>"##)),
        pict(r##"<v:shape type="#_x0000_t13" style="position:absolute;margin-left:10pt;margin-top:5pt;width:60pt;height:20pt;z-index:2" fillcolor="#00ff00" strokecolor="#0000ff" strokeweight="2pt"/>"##),
        pict(r##"<v:shape o:spt="74" style="width:30pt;height:30pt" fillcolor="red" stroked="f"/>"##),
        pict(r##"<v:shapetype id="tri" o:spt="5" coordsize="21600,21600"/><v:shape type="#tri" style="width:20pt;height:10pt" filled="f"/>"##),
        pict(r##"<v:shape type="#_x0000_t4" style="width:50pt;height:50pt" fillcolor="#ffff00"><v:textbox><w:txbxContent><w:p><w:r><w:t>yes?</w:t></w:r></w:p></w:txbxContent></v:textbox></v:shape>"##),
        // A preset WordCraft has no shape for is drawn as the nearest one, as for DrawingML: a
        // right triangle (`o:spt` 6) as a triangle.
        pict(r##"<v:shape type="#_x0000_t6" style="width:20pt;height:20pt" fillcolor="red"/>"##),
        // Its own path wins over the shapetype's: not the preset.
        pict(r##"<v:shape type="#_x0000_t13" path="m,l21600,21600e" style="width:20pt;height:20pt"/>"##),
        // Lines from a shapetype (`o:spt` 20 and Word's line tool's 32) take the size of their box.
        pict(r##"<v:shape type="#_x0000_t20" style="width:40pt;height:10pt"/>"##),
        pict(r##"<v:shapetype id="_x0000_t32" coordsize="21600,21600" o:spt="32" o:oned="t" path="m,l21600,21600e" filled="f"/><v:shape type="#_x0000_t32" style="position:absolute;width:30pt;height:15pt" strokecolor="#ff0000"><v:stroke endarrow="block"/></v:shape>"##),
        // A text box's shapetype without text is still a text box.
        pict(r##"<v:shape type="#_x0000_t202" style="width:30pt;height:15pt"/>"##),
        // A shape that isn't a preset keeps its text, in a text box.
        pict(r##"<v:shape o:spt="0" style="width:50pt;height:50pt"><v:textbox><w:txbxContent><w:p/></w:txbxContent></v:textbox></v:shape>"##),
        // Text in a preset with neither fill nor outline is kept.
        pict(r##"<v:shape type="#_x0000_t3" style="width:50pt;height:50pt" filled="f" stroked="f"><v:textbox><w:txbxContent><w:p/></w:txbxContent></v:textbox></v:shape>"##),
        pict(r##"<v:oval style="width:50pt;height:40pt"><v:textbox><w:txbxContent><w:p/></w:txbxContent></v:textbox></v:oval>"##),
        // Paint the shape leaves out comes from its shapetype.
        pict(r##"<v:shapetype id="_x0000_t1" o:spt="1" fillcolor="#0000ff" stroked="f"/><v:shape type="#_x0000_t1" style="width:9pt;height:9pt"/>"##),
        r##"<w:p><w:r><w:pict><v:shape type="#_x0000_t2" style="width:9pt;height:9pt"/></w:pict></w:r><w:r><w:pict><v:shape type="#_x0000_t12" style="width:9pt;height:9pt"/></w:pict></w:r></w:p>"##.to_string(),
        pict(r##"<v:shape type="#_x0000_t109" style="width:9pt;height:9pt"/>"##),
        pict(r##"<v:shape type="#_x0000_t110" style="width:9pt;height:9pt"/>"##),
        pict(r##"<v:shape type="#_x0000_t120" style="width:9pt;height:9pt"/>"##),
        // Nearest shapes: left arrow, rectangular callout, four-point star.
        pict(r##"<v:shape type="#_x0000_t66" style="width:60pt;height:20pt" fillcolor="#ffa500"/>"##),
        pict(r##"<v:shape type="#_x0000_t61" style="width:60pt;height:20pt"/>"##),
        pict(r##"<v:shape type="#_x0000_t187" style="width:20pt;height:20pt"/>"##),
        // Not drawn: WordArt text (136) and a picture frame without its picture (75).
        pict(r##"<v:shape type="#_x0000_t136" style="width:60pt;height:20pt" fillcolor="silver"/>"##),
        pict(r##"<v:shape type="#_x0000_t75" style="width:60pt;height:20pt"/>"##),
    ]
    .concat();
    let d = read_body(&body);
    let ps = paras(&d);
    let shape = |i: usize| match ps[i].objects.first() {
        Some(InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, story, .. }) => {
            Some((*kind, *w, *h, fill.as_ref().map(Fill::main_color), *stroke, *stroke_width, float.wrap == Wrap::Inline, story.is_some()))
        }
        _ => None,
    };
    let kind = |i: usize| shape(i).map(|s| (s.0, s.7));
    let (black, white) = (Some(Rgb::BLACK), Some(Rgb::WHITE));
    assert_eq!(shape(0), Some((ShapeKind::Arrow, 120.0, 40.0, Some(Rgb(0xFF, 0xA5, 0x00)), black, 0.75, true, false)));
    assert_eq!(shape(1), Some((ShapeKind::Arrow, 60.0, 20.0, Some(Rgb(0, 0xFF, 0)), Some(Rgb(0, 0, 0xFF)), 2.0, false, false)));
    assert_eq!(shape(2), Some((ShapeKind::Heart, 30.0, 30.0, Some(Rgb(0xFF, 0, 0)), None, 0.75, true, false)));
    assert_eq!(shape(3), Some((ShapeKind::Triangle, 20.0, 10.0, None, black, 0.75, true, false)));
    // A preset holding text keeps its geometry around the text.
    assert_eq!(shape(4), Some((ShapeKind::Diamond, 50.0, 50.0, Some(Rgb(0xFF, 0xFF, 0)), black, 0.75, true, true)));
    assert_eq!(shape(5), Some((ShapeKind::RightTriangle, 20.0, 20.0, Some(Rgb(0xFF, 0, 0)), black, 0.75, true, false)));
    // Its own path is drawn as a freeform, not as the shapetype's arrow.
    assert_eq!(kind(6), Some((ShapeKind::Freeform, false)));
    assert_eq!(shape(7), Some((ShapeKind::Line, 40.0, 10.0, None, black, 0.75, true, false)));
    assert_eq!(shape(8), Some((ShapeKind::Line, 30.0, 15.0, None, Some(Rgb(0xFF, 0, 0)), 0.75, false, false)));
    assert!(matches!(ps[8].objects.first(), Some(InlineObject::Shape { extra, .. }) if extra.arrow_end && !extra.arrow_start));
    assert_eq!(shape(9), Some((ShapeKind::TextBox, 30.0, 15.0, white, black, 0.75, true, false)));
    assert_eq!(kind(10), Some((ShapeKind::TextBox, true)));
    assert_eq!(shape(11), Some((ShapeKind::Ellipse, 50.0, 50.0, None, None, 0.75, true, true)));
    assert_eq!(kind(12), Some((ShapeKind::Ellipse, true)));
    assert_eq!(shape(13), Some((ShapeKind::Rectangle, 9.0, 9.0, Some(Rgb(0, 0, 0xFF)), None, 0.75, true, false)));
    let kinds: Vec<_> = ps[14].objects.iter().filter_map(|o| if let InlineObject::Shape { kind, .. } = o { Some(*kind) } else { None }).collect();
    assert_eq!(kinds, [ShapeKind::RoundedRectangle, ShapeKind::Star]);
    assert_eq!(kind(15), Some((ShapeKind::Rectangle, false)));
    assert_eq!(kind(16), Some((ShapeKind::Diamond, false)));
    assert_eq!(kind(17), Some((ShapeKind::Ellipse, false)));
    assert_eq!(shape(18), Some((ShapeKind::ArrowLeft, 60.0, 20.0, Some(Rgb(0xFF, 0xA5, 0x00)), black, 0.75, true, false)));
    assert_eq!(kind(19), Some((ShapeKind::Rectangle, false)));
    assert_eq!(kind(20), Some((ShapeKind::Star, false)));
    assert_eq!(shape(21), None);
    assert_eq!(shape(22), None);
}

/// #1377: hostile shape type numbers and references are skipped, never a panic.
#[test]
fn vml_preset_hostile_types_never_panic() {
    let shapes = [
        r##"<v:shape o:spt="99999999999999999999999" style="width:9pt;height:9pt"/>"##,
        r##"<v:shape o:spt="-13" style="width:9pt;height:9pt"/>"##,
        r##"<v:shape o:spt="" type="#_x0000_t" style="width:9pt;height:9pt"/>"##,
        r##"<v:shape type="#_x0000_t13abc" style="width:9pt;height:9pt"/>"##,
        r##"<v:shape type="#" style="width:9pt;height:9pt"/>"##,
        r##"<v:shape type="#_x0000_tépée" style="width:9pt;height:9pt"/>"##,
        r##"<v:shapetype id="x" o:spt="nope"/><v:shape type="#x" style="width:9pt;height:9pt"/>"##,
        r##"<v:shape type="#_x0000_t13" style="width:-1e39pt;height:NaNpt" fillcolor="#zzz" strokeweight="1e30pt"/>"##,
    ];
    let body: String = shapes.iter().map(|s| format!("<w:p><w:r><w:pict>{s}</w:pict></w:r></w:p>")).collect();
    let d = read_body(&body);
    for (i, p) in paras(&d).iter().enumerate().take(7) {
        assert!(p.objects.is_empty(), "shape {i}: {:?}", p.objects);
    }
    match paras(&d)[7].objects.first() {
        Some(InlineObject::Shape { kind: ShapeKind::Arrow, w, h, stroke_width, .. }) => {
            assert!(w.is_finite() && h.is_finite() && *w >= 0.0 && *h >= 0.0 && *stroke_width <= 100.0)
        }
        o => panic!("{o:?}"),
    }
}

/// #1377: a VML preset shape is kept on save, as its DrawingML preset with its fill.
#[test]
fn vml_preset_shape_survives_saving() {
    let body = format!(
        r##"<w:p><w:r><w:pict>{VML_RIGHT_ARROW_TYPE}<v:shape type="#_x0000_t13" style="width:120pt;height:40pt" fillcolor="#ffa500"/></w:pict></w:r></w:p>"##
    );
    let saved = craft_docx::write(&read_body(&body)).unwrap();
    let mut z = zip::ZipArchive::new(std::io::Cursor::new(saved.as_slice())).unwrap();
    let mut xml = String::new();
    std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
    assert!(xml.contains(r#"prst="rightArrow""#), "{xml}");
    let again = craft_docx::read(&saved).unwrap();
    assert!(
        matches!(
            &paras(&again)[0].objects[..],
            [InlineObject::Shape {
                kind: ShapeKind::Arrow,
                w: 120.0,
                h: 40.0,
                fill: Some(Fill::Solid { color: Rgb(0xFF, 0xA5, 0x00), .. }),
                stroke: Some(Rgb::BLACK),
                ..
            }]
        ),
        "{:?}",
        paras(&again)[0].objects
    );
}

/// #1377: a VML preset drawn as its nearest shape (a left arrow, `o:spt` 66) is kept on save as
/// that shape's DrawingML preset, as a DrawingML left arrow is.
#[test]
fn vml_nearest_preset_shape_survives_saving() {
    let body = r##"<w:p><w:r><w:pict><v:shape type="#_x0000_t66" style="width:60pt;height:20pt" fillcolor="#ffa500"/></w:pict></w:r></w:p>"##;
    let saved = craft_docx::write(&read_body(body)).unwrap();
    let mut z = zip::ZipArchive::new(std::io::Cursor::new(saved.as_slice())).unwrap();
    let mut xml = String::new();
    std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
    assert!(xml.contains(r#"prst="leftArrow""#), "{xml}");
    let again = craft_docx::read(&saved).unwrap();
    assert!(
        matches!(
            &paras(&again)[0].objects[..],
            [InlineObject::Shape { kind: ShapeKind::ArrowLeft, w: 60.0, h: 20.0, fill: Some(Fill::Solid { color: Rgb(0xFF, 0xA5, 0x00), .. }), .. }]
        ),
        "{:?}",
        paras(&again)[0].objects
    );
}

/// #743: a cover page from Word: a group holding a rectangle filled through its style, a
/// freeform band and a title box, beside a box that resizes to fit its two lines and has no
/// internal margins. The fills, the band's outline, the margins and the resizing are all read
/// and survive saving.
#[test]
fn cover_page_group_fills_freeforms_and_text_box_margins() {
    let style = r#"<wps:style><a:lnRef idx="2"><a:schemeClr val="accent1"><a:shade val="50000"/></a:schemeClr></a:lnRef><a:fillRef idx="1"><a:schemeClr val="accent1"/></a:fillRef><a:effectRef idx="0"><a:schemeClr val="accent1"/></a:effectRef><a:fontRef idx="minor"><a:schemeClr val="lt1"/></a:fontRef></wps:style>"#;
    let member = |id: u32, txbox: bool, off: (u32, u32), ext: (u32, u32), geom: &str, paint: &str, inner: &str| {
        let nv = if txbox { r#"<wps:cNvSpPr txBox="1"/>"# } else { "<wps:cNvSpPr/>" };
        format!(
            r#"<wps:wsp><wps:cNvPr id="{id}" name="Member {id}"/>{nv}<wps:spPr><a:xfrm><a:off x="{}" y="{}"/><a:ext cx="{}" cy="{}"/></a:xfrm>{geom}{paint}</wps:spPr>{style}{inner}</wps:wsp>"#,
            off.0, off.1, ext.0, ext.1
        )
    };
    let rect = r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>"#;
    let band = r#"<a:custGeom><a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/><a:rect l="0" t="0" r="r" b="b"/><a:pathLst><a:path w="100" h="100"><a:moveTo><a:pt x="0" y="100"/></a:moveTo><a:lnTo><a:pt x="100" y="0"/></a:lnTo><a:lnTo><a:pt x="100" y="100"/></a:lnTo><a:close/></a:path></a:pathLst></a:custGeom>"#;
    let title = r#"<wps:txbx><w:txbxContent><w:p><w:r><w:t>Cover Title</w:t></w:r></w:p></w:txbxContent></wps:txbx><wps:bodyPr rot="0" vert="horz" wrap="square" lIns="0" tIns="0" rIns="0" bIns="0" anchor="t"><a:noAutofit/></wps:bodyPr>"#;
    let members = [
        member(11, false, (0, 0), (5486400, 5486400), rect, r#"<a:ln><a:noFill/></a:ln>"#, "<wps:bodyPr/>"),
        member(
            12,
            false,
            (914400, 4572000),
            (4572000, 914400),
            band,
            r#"<a:solidFill><a:schemeClr val="bg1"/></a:solidFill><a:ln><a:noFill/></a:ln>"#,
            "<wps:bodyPr/>",
        ),
        member(13, true, (457200, 457200), (4572000, 1828800), rect, r#"<a:noFill/><a:ln><a:noFill/></a:ln>"#, title),
    ]
    .concat();
    let group = format!(
        r##"<w:r><mc:AlternateContent><mc:Choice Requires="wpg"><w:drawing><wp:anchor distT="0" distB="0" distL="0" distR="0" simplePos="0" relativeHeight="1" behindDoc="1" locked="0" layoutInCell="1" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="margin"><wp:align>center</wp:align></wp:positionH><wp:positionV relativeFrom="margin"><wp:align>top</wp:align></wp:positionV><wp:extent cx="5486400" cy="5486400"/><wp:effectExtent l="0" t="0" r="0" b="0"/><wp:wrapNone/><wp:docPr id="1" name="Group 1"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup"><wpg:wgp><wpg:cNvGrpSpPr/><wpg:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="5486400" cy="5486400"/><a:chOff x="0" y="0"/><a:chExt cx="5486400" cy="5486400"/></a:xfrm></wpg:grpSpPr>{members}</wpg:wgp></a:graphicData></a:graphic></wp:anchor></w:drawing></mc:Choice><mc:Fallback><w:pict><v:rect style="width:10pt;height:10pt" fillcolor="#156082 [3204]" stroked="f"/></w:pict></mc:Fallback></mc:AlternateContent></w:r>"##
    );
    let subtitle = anchored_wsp(
        "Subtitle",
        5753100,
        420000,
        r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:noFill/><a:ln><a:noFill/></a:ln>"#,
        "",
        r#"<wps:cNvSpPr txBox="1"/><wps:txbx><w:txbxContent><w:p><w:r><w:t>Plan</w:t></w:r></w:p><w:p><w:r><w:t>Author</w:t></w:r></w:p></w:txbxContent></wps:txbx>"#,
    )
    // `anchored_wsp` writes an empty `wps:bodyPr`: give this one margins and Resize to fit.
    .replace("<wps:bodyPr/>", r#"<wps:bodyPr lIns="0" tIns="12700" rIns="0" bIns="0"><a:spAutoFit/></wps:bodyPr>"#);
    let check = |d: &Document| {
        let theme = &d.settings.theme_colors;
        let objs = &paras(d)[0].objects;
        let InlineObject::Group { children, .. } = &objs[0] else { panic!("{:?}", objs[0]) };
        assert_eq!(children.len(), 3);
        let shape = |i: usize| match &children[i].obj {
            InlineObject::Shape { kind, fill, freeform, story, .. } => (*kind, fill.as_ref().map(Fill::main_color), freeform.is_some(), *story),
            o => panic!("{o:?}"),
        };
        let (kind, fill, free, _) = shape(0);
        assert_eq!((kind, fill, free), (ShapeKind::Rectangle, Some(theme[4]), false), "the style's accent fill");
        let (kind, fill, free, _) = shape(1);
        assert_eq!((kind, fill, free), (ShapeKind::Freeform, Some(theme[1]), true), "a freeform in a group keeps its outline");
        let (kind, _, _, story) = shape(2);
        assert_eq!(kind, ShapeKind::TextBox);
        let body = d.parts[&story.unwrap()].body;
        assert_eq!((body.inset, body.auto_fit), (Some([0; 4]), false), "the title box has no margins");
        let InlineObject::Shape { story: Some(sub), .. } = &objs[1] else { panic!("{:?}", objs[1]) };
        let body = d.parts[sub].body;
        assert_eq!((body.inset, body.auto_fit), (Some([0, 12700, 0, 0]), true), "the subtitle resizes to fit its text");
    };
    let d = read_body(&format!("<w:p>{group}{subtitle}</w:p>"));
    check(&d);
    check(&craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap());
}

/// #886: saving dropped Word's DrawingML shapes (rectangles, ellipses, triangles, arrows,
/// stars, connectors and their theme fills). Each kind the report lists is read, saved and read
/// back with the same kind, fill, outline, size and position, and the saved part still holds a
/// `wps:wsp` with its preset geometry.
#[test]
fn drawingml_shapes_survive_saving() {
    let style = r#"<wps:style><a:lnRef idx="2"><a:schemeClr val="accent1"><a:shade val="15000"/></a:schemeClr></a:lnRef><a:fillRef idx="1"><a:schemeClr val="accent1"/></a:fillRef><a:effectRef idx="0"><a:schemeClr val="accent1"/></a:effectRef><a:fontRef idx="minor"><a:schemeClr val="lt1"/></a:fontRef></wps:style>"#;
    let geom = |prst: &str| format!(r#"<a:prstGeom prst="{prst}"><a:avLst/></a:prstGeom>"#);
    let presets = ["rect", "ellipse", "triangle", "rightArrow", "star5"];
    let mut body: String = presets.iter().map(|p| anchored_wsp(p, 2009775, 819150, &geom(p), style, "<wps:cNvSpPr/>")).collect();
    body.push_str(&anchored_wsp(
        "Connector",
        2362200,
        390525,
        r#"<a:prstGeom prst="straightConnector1"><a:avLst/></a:prstGeom><a:ln><a:tailEnd type="triangle"/></a:ln>"#,
        style,
        "<wps:cNvCnPr/>",
    ));
    body.push_str(&anchored_wsp(
        "Text Box",
        2324100,
        571500,
        r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:solidFill><a:schemeClr val="lt1"/></a:solidFill><a:ln w="9525"><a:solidFill><a:srgbClr val="7F7F7F"/></a:solidFill></a:ln>"#,
        "",
        r#"<wps:cNvSpPr txBox="1"/><wps:txbx><w:txbxContent><w:p><w:r><w:t>Floating text box</w:t></w:r></w:p></w:txbxContent></wps:txbx>"#,
    ));
    let shapes = |d: &Document| {
        paras(d)[0]
            .objects
            .iter()
            .map(|o| match o {
                InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, extra, .. } => {
                    (*kind, *w, *h, fill.clone(), *stroke, *stroke_width, float.x, float.y, float.wrap, extra.arrow_end)
                }
                o => panic!("{o:?}"),
            })
            .collect::<Vec<_>>()
    };
    let d = read_body(&format!("<w:p>{body}</w:p>"));
    let accent = d.settings.theme_colors[4];
    let read = shapes(&d);
    let kinds: Vec<ShapeKind> = read.iter().map(|s| s.0).collect();
    assert_eq!(
        kinds,
        [
            ShapeKind::Rectangle,
            ShapeKind::Ellipse,
            ShapeKind::Triangle,
            ShapeKind::Arrow,
            ShapeKind::Star,
            ShapeKind::StraightConnector,
            ShapeKind::TextBox
        ]
    );
    for s in &read[..5] {
        assert_eq!(s.3, Some(craft_wordmodel::fill::Fill::solid(accent)), "{:?} is filled from the theme", s.0);
        assert!(s.4.is_some() && s.5 > 0.0, "{:?} has its outline", s.0);
        assert_eq!((s.6, s.7, s.8), (1.0, 2.0, Wrap::InFrontOfText), "{:?} keeps its place", s.0);
    }
    assert!(read[5].9, "the connector keeps its arrowhead");
    let bytes = craft_docx::write(&d).unwrap();
    let again = craft_docx::read(&bytes).unwrap();
    assert_eq!(shapes(&again), read, "every shape survives saving");
    assert_eq!(part_text_box(&again), "Floating text box");
    let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes[..])).unwrap();
    let mut xml = String::new();
    std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
    assert_eq!(xml.matches("<wps:wsp>").count(), 7);
    for p in presets.iter().chain(&["straightConnector1"]) {
        assert!(xml.contains(&format!(r#"<a:prstGeom prst="{p}">"#)), "{p} is written");
    }
}

/// The text of the first text box in `d`.
fn part_text_box(d: &Document) -> String {
    let story = paras(d)[0].objects.iter().find_map(|o| match o {
        InlineObject::Shape { kind: ShapeKind::TextBox, story, .. } => *story,
        _ => None,
    });
    story.and_then(|id| d.parts.get(&id)).map(|p| p.blocks.iter().filter_map(|b| b.as_para()).map(|p| p.plain_text()).collect()).unwrap_or_default()
}

/// #743: Word's cover pages place their shapes relative to the page's size, wrapped in
/// `mc:AlternateContent` with an offset as the Fallback, and draw their freeforms back to the
/// start without `a:close`. Both shapes are read: placed at the offset, and filled.
#[test]
fn cover_page_relative_position_and_freeform_drawn_back_to_its_start() {
    let geom = r#"<a:custGeom><a:avLst/><a:gdLst/><a:ahLst/><a:cxnLst/><a:rect l="0" t="0" r="r" b="b"/><a:pathLst><a:path w="100" h="100"><a:moveTo><a:pt x="0" y="0"/></a:moveTo><a:lnTo><a:pt x="0" y="90"/></a:lnTo><a:cubicBezTo><a:pt x="30" y="100"/><a:pt x="70" y="100"/><a:pt x="100" y="90"/></a:cubicBezTo><a:lnTo><a:pt x="100" y="0"/></a:lnTo><a:lnTo><a:pt x="0" y="0"/></a:lnTo></a:path><a:path w="100" h="100"><a:moveTo><a:pt x="0" y="50"/></a:moveTo><a:lnTo><a:pt x="100" y="50"/></a:lnTo></a:path></a:pathLst></a:custGeom><a:solidFill><a:srgbClr val="0E2841"/></a:solidFill>"#;
    let pct = r#"<mc:AlternateContent><mc:Choice Requires="wp14"><wp:positionV relativeFrom="page"><wp14:pctPosVOffset>4500</wp14:pctPosVOffset></wp:positionV></mc:Choice><mc:Fallback><wp:positionV relativeFrom="page"><wp:posOffset>480695</wp:posOffset></wp:positionV></mc:Fallback></mc:AlternateContent>"#;
    let shape = anchored_wsp("Freeform 1", 5486400, 5334000, geom, "", "<wps:cNvSpPr/>")
        .replace(r#"<wp:positionV relativeFrom="paragraph"><wp:posOffset>25400</wp:posOffset></wp:positionV>"#, pct);
    let check = |d: &Document| {
        let objs = &paras(d)[0].objects;
        let InlineObject::Shape { kind, float, freeform: Some(f), .. } = &objs[0] else { panic!("{:?}", objs[0]) };
        assert_eq!(*kind, ShapeKind::Freeform);
        assert_eq!((float.v_rel, float.v_align, float.y), (Anchor::Page, None, 480695.0 / 12700.0), "the Fallback's offset");
        let closed: Vec<bool> = f.paths.iter().map(|p| p.closed).collect();
        assert_eq!(closed, [true, false], "a path back at its start is closed and filled; an open line isn't");
    };
    let d = read_body(&format!("<w:p>{shape}</w:p>"));
    check(&d);
    check(&craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap());
}

#[test]
fn embedded_fonts_survive_a_round_trip() {
    let table = r#"<w:fonts xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><w:font w:name="Roboto"><w:embedRegular r:id="rId1"/><w:embedBold r:id="rId2"/></w:font></w:fonts>"#;
    let table_rels = rels(&[("rId1", "font", "fonts/Roboto-regular.ttf"), ("rId2", "font", "fonts/Roboto-bold.ttf")]);
    let bytes = docx(
        "<w:p><w:r><w:t>Hi</w:t></w:r></w:p>",
        &[("rId9", "fontTable", "fontTable.xml")],
        &[
            ("word/fontTable.xml", table),
            ("word/_rels/fontTable.xml.rels", &table_rels),
            ("word/fonts/Roboto-regular.ttf", "regular font bytes"),
            ("word/fonts/Roboto-bold.ttf", "bold font bytes"),
        ],
    );
    let out = craft_docx::write(&craft_docx::read(&bytes).unwrap()).unwrap();
    let files = unzip(&out);
    assert_eq!(text(&files, "word/fontTable.xml"), table);
    assert_eq!(text(&files, "word/fonts/Roboto-regular.ttf"), "regular font bytes");
    assert_eq!(text(&files, "word/fonts/Roboto-bold.ttf"), "bold font bytes");
    let table_rels = text(&files, "word/_rels/fontTable.xml.rels");
    assert!(table_rels.contains(r#"Id="rId1""#) && table_rels.contains("fonts/Roboto-regular.ttf"), "{table_rels}");
    assert!(text(&files, "word/_rels/document.xml.rels").contains("fontTable.xml"));
    // A second save keeps them too.
    let again = unzip(&craft_docx::write(&craft_docx::read(&out).unwrap()).unwrap());
    assert_eq!(text(&again, "word/fonts/Roboto-bold.ttf"), "bold font bytes");
}

// ---- native Word ink: opaque preservation, never re-encoded as WordCraft freeforms ----

const INK_NS: &str = "http://schemas.microsoft.com/office/word/2010/wordprocessingInk";
const INK_XML: &str = r##"<ink xmlns="http://www.w3.org/2003/InkML"><definitions><context xml:id="ctx"><inkSource xml:id="src"><traceFormat><channel name="X" type="integer" units="cm"/><channel name="Y" type="integer" units="cm"/></traceFormat></inkSource></context><brush xml:id="blue"><brushProperty name="color" value="#2563EB"/><brushProperty name="width" value="0.08" units="cm"/></brush></definitions><trace contextRef="#ctx" brushRef="#blue">0 0, 1 1, 2 0</trace></ink>"##;
const INK_TYPES: &str = r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Override PartName="/word/ink/ink1.xml" ContentType="application/inkml+xml"/><Default Extension="png" ContentType="image/png"/></Types>"#;

fn ink_docx(fallback: bool, alias: bool) -> Vec<u8> {
    let content = r#"<q:contentPart xmlns:q="http://schemas.microsoft.com/office/word/2010/wordml" r:id="rInk"><q:xfrm><a:off x="0" y="0"/><a:ext cx="1828800" cy="914400"/></q:xfrm></q:contentPart>"#;
    let drawing = format!(
        r#"<w:drawing><wp:inline><wp:extent cx="1828800" cy="914400"/><wp:docPr id="1" name="Study ink"/><a:graphic><a:graphicData uri="{INK_NS}">{content}</a:graphicData></a:graphic></wp:inline></w:drawing>"#
    );
    let prefix = if alias { "pen" } else { "wpi" };
    let markup = if fallback {
        format!(
            r##"<mc:AlternateContent><mc:Choice xmlns:{prefix}="{INK_NS}" Requires="{prefix}">{drawing}</mc:Choice><mc:Fallback><w:pict><v:shape id="preview" style="width:144pt;height:72pt"><v:imagedata r:id="rPreview"/></v:shape></w:pict></mc:Fallback></mc:AlternateContent>"##
        )
    } else {
        drawing
    };
    let body = format!("<w:p><w:r><w:t>Original</w:t></w:r></w:p><w:p><w:r>{markup}</w:r></w:p>");
    let mut relationships = vec![("rInk", "customXml", "ink/ink1.xml")];
    let mut extra = vec![("[Content_Types].xml", INK_TYPES), ("word/ink/ink1.xml", INK_XML)];
    if fallback {
        relationships.push(("rPreview", "image", "media/preview.png"));
        extra.push(("word/media/preview.png", "original preview bytes"));
    }
    docx(&body, &relationships, &extra)
}

fn check_ink(files: &std::collections::BTreeMap<String, Vec<u8>>) -> String {
    let body = text(files, "word/document.xml");
    let [id] = attr_values(&body, "w14:contentPart", "r:id").try_into().unwrap_or_else(|_| panic!("ink reference lost: {body}"));
    let (kind, target) = rel(&text(files, "word/_rels/document.xml.rels"), &id);
    assert!(kind.ends_with("/customXml"));
    let part = part_at("word", &target);
    assert_eq!(text(files, &part), INK_XML);
    assert!(text(files, "[Content_Types].xml").contains(&format!(r#"PartName="/{part}" ContentType="application/inkml+xml""#)));
    part
}

#[test]
fn native_ink_survives_unrelated_edit_and_two_saves() {
    let mut d = craft_docx::read(&ink_docx(false, false)).unwrap();
    let g = graphics(&d);
    assert_eq!(g.len(), 1, "native ink must remain a model object");
    let InlineObject::Graphic { graphic, .. } = &g[0] else { panic!() };
    assert_eq!(graphic.kind.noun(), "ink");
    assert!(graphic.source.is_some());
    assert!(!graphic.items.is_empty(), "a missing preview must not silently leave a blank frame");
    let p = std::sync::Arc::make_mut(&mut d.body[0]);
    let Block::Para(p) = p else { panic!() };
    p.delete(0, p.len()).unwrap();
    p.insert_text(0, "Edited", &Default::default()).unwrap();
    for _ in 0..2 {
        let out = craft_docx::write(&d).unwrap();
        let files = unzip(&out);
        check_ink(&files);
        assert!(text(&files, "word/document.xml").contains("Edited"));
        d = craft_docx::read(&out).unwrap();
        assert_eq!(graphics(&d).len(), 1);
    }
}

#[test]
fn direct_native_ink_content_part_survives_unrelated_edit_and_two_saves() {
    let body = r#"<w:p><w:r><w:t>Original</w:t></w:r><w:r><w:contentPart r:id="rInk"/></w:r></w:p>"#;
    let mut d = craft_docx::read(&docx(
        body,
        &[("rInk", "customXml", "ink/ink1.xml")],
        &[("[Content_Types].xml", INK_TYPES), ("word/ink/ink1.xml", INK_XML)],
    ))
    .unwrap();
    assert_eq!(graphics(&d).len(), 1, "direct native ink must remain a model object");
    let p = std::sync::Arc::make_mut(&mut d.body[0]);
    let Block::Para(p) = p else { panic!() };
    p.delete(0, 8).unwrap();
    p.insert_text(0, "Edited", &Default::default()).unwrap();
    for _ in 0..2 {
        let out = craft_docx::write(&d).unwrap();
        let files = unzip(&out);
        let body = text(&files, "word/document.xml");
        assert!(body.contains("<w:contentPart"), "direct content part must stay direct: {body}");
        let [id] = attr_values(&body, "w:contentPart", "r:id").try_into().unwrap();
        let (kind, target) = rel(&text(&files, "word/_rels/document.xml.rels"), &id);
        assert!(kind.ends_with("/customXml"));
        let part = part_at("word", &target);
        assert_eq!(text(&files, &part), INK_XML);
        assert!(text(&files, "[Content_Types].xml").contains(&format!(r#"PartName="/{part}" ContentType="application/inkml+xml""#)));
        d = craft_docx::read(&out).unwrap();
        assert_eq!(graphics(&d).len(), 1);
    }
}

#[test]
fn native_ink_keeps_alternate_content_and_preview_with_renamed_prefixes() {
    for alias in [false, true] {
        let mut d = craft_docx::read(&ink_docx(true, alias)).unwrap();
        let g = graphics(&d);
        assert_eq!(g.len(), 1, "fallback must not replace native ink");
        let InlineObject::Graphic { graphic, .. } = &g[0] else { panic!() };
        assert!(
            graphic
                .items
                .iter()
                .any(|item| matches!(item, craft_wordmodel::graphic::GraphicItem::Image { media, .. } if d.media.contains_key(media)))
        );
        for _ in 0..2 {
            let out = craft_docx::write(&d).unwrap();
            let files = unzip(&out);
            check_ink(&files);
            let body = text(&files, "word/document.xml");
            assert!(body.contains("<mc:AlternateContent>") && body.contains("<mc:Fallback>"));
            let [id] = attr_values(&body, "v:imagedata", "r:id").try_into().unwrap();
            let (kind, target) = rel(&text(&files, "word/_rels/document.xml.rels"), &id);
            assert!(kind.ends_with("/image"));
            assert_eq!(text(&files, &part_at("word", &target)), "original preview bytes");
            d = craft_docx::read(&out).unwrap();
            assert_eq!(graphics(&d).len(), 1);
        }
    }
}

#[test]
fn native_ink_missing_part_uses_available_fallback() {
    let bytes = ink_docx(true, true);
    let mut files = unzip(&bytes);
    files.remove("word/ink/ink1.xml");
    let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
    let d = craft_docx::read(&zip(&entries)).unwrap();
    assert!(graphics(&d).is_empty());
    assert!(paras(&d).iter().flat_map(|p| &p.objects).any(|o| matches!(o, InlineObject::Image { .. })));
    let files = unzip(&craft_docx::write(&d).unwrap());
    assert!(!text(&files, "word/document.xml").contains("w14:contentPart"));
    assert!(files.values().any(|bytes| bytes == b"original preview bytes"));
}

#[test]
fn native_ink_missing_optional_preview_keeps_native_part() {
    let mut files = unzip(&ink_docx(true, false));
    files.remove("word/media/preview.png");
    let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
    let d = craft_docx::read(&zip(&entries)).unwrap();
    assert_eq!(graphics(&d).len(), 1);
    let files = unzip(&craft_docx::write(&d).unwrap());
    check_ink(&files);
    assert!(!text(&files, "word/document.xml").contains("<mc:Fallback>"));
}

#[test]
fn native_ink_requires_the_bound_namespace_and_ink_content_type() {
    for wrong_namespace in [true, false] {
        let mut files = unzip(&ink_docx(true, false));
        let name = if wrong_namespace { "word/document.xml" } else { "[Content_Types].xml" };
        let old = text(&files, name);
        let changed = if wrong_namespace {
            old.replace(&format!(r#"xmlns:wpi="{INK_NS}""#), r#"xmlns:wpi="urn:future:unsupported""#)
        } else {
            old.replace("application/inkml+xml", "application/xml")
        };
        files.insert(name.into(), changed.into_bytes());
        let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
        let d = craft_docx::read(&zip(&entries)).unwrap();
        assert!(graphics(&d).is_empty());
        assert!(paras(&d).iter().flat_map(|p| &p.objects).any(|o| matches!(o, InlineObject::Image { .. })));
    }
}

#[test]
fn native_ink_copies_have_independent_parts_and_current_frames() {
    let mut d = craft_docx::read(&ink_docx(true, false)).unwrap();
    let [mut object] = graphics(&d).try_into().unwrap();
    let InlineObject::Graphic { w, h, float, .. } = &mut object else { panic!() };
    (*w, *h) = (288.0, 144.0);
    *float = craft_wordmodel::para::Float { wrap: Wrap::Square, h_rel: Anchor::Page, v_rel: Anchor::Page, x: 72.0, y: 36.0, ..Default::default() };
    let mut p = Paragraph::new();
    p.insert_object(0, object.clone(), &Default::default()).unwrap();
    p.insert_object(p.len(), object, &Default::default()).unwrap();
    d.body = vec![craft_wordmodel::para_block(p)];
    let out = craft_docx::write(&d).unwrap();
    let files = unzip(&out);
    let body = text(&files, "word/document.xml");
    let ids = attr_values(&body, "w14:contentPart", "r:id");
    assert_eq!(ids.len(), 2);
    let parts: Vec<_> = ids.iter().map(|id| part_at("word", &rel(&text(&files, "word/_rels/document.xml.rels"), id).1)).collect();
    assert_ne!(parts[0], parts[1]);
    for part in parts {
        assert_eq!(text(&files, &part), INK_XML);
    }
    assert_eq!(attr_values(&body, "wp:extent", "cx"), ["3657600", "3657600"]);
    assert_eq!(attr_values(&body, "a:ext", "cx"), ["3657600", "3657600"]);
    assert_eq!(attr_values(&body, "v:shape", "style"), ["width:288pt;height:144pt", "width:288pt;height:144pt"]);
    assert_eq!(body.matches("<wp:posOffset>914400</wp:posOffset>").count(), 2);
    let back = craft_docx::read(&out).unwrap();
    let g = graphics(&back);
    assert_eq!(g.len(), 2);
    for object in g {
        let InlineObject::Graphic { w, h, float, .. } = object else { panic!() };
        assert_eq!((w, h, float.x, float.y), (288.0, 144.0, 72.0, 36.0));
    }
}

#[test]
fn native_ink_markup_limit_does_not_write_a_dangling_reference() {
    let mut files = unzip(&ink_docx(false, false));
    let body = text(&files, "word/document.xml").replace("<a:graphicData ", &format!(r#"<a:graphicData padding="{}" "#, "x".repeat(1024 * 1024 + 1)));
    files.insert("word/document.xml".into(), body.into_bytes());
    let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
    let d = craft_docx::read(&zip(&entries)).unwrap();
    let files = unzip(&craft_docx::write(&d).unwrap());
    assert!(!text(&files, "word/document.xml").contains("w14:contentPart"));
}

#[test]
fn native_ink_preserves_inner_transform_and_rotation_padding_on_unrelated_saves() {
    let mut files = unzip(&ink_docx(false, false));
    let body = text(&files, "word/document.xml")
        .replace("<wp:docPr", r#"<wp:effectExtent l="55468" t="512668" r="55468" b="512668"/><wp:docPr"#)
        .replace("<q:xfrm>", r#"<q:xfrm rot="2700000">"#)
        .replace(r#"<a:off x="0" y="0"/><a:ext cx="1828800" cy="914400"/>"#, r#"<a:off x="127000" y="254000"/><a:ext cx="914400" cy="457200"/>"#);
    files.insert("word/document.xml".into(), body.into_bytes());
    let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
    let mut d = craft_docx::read(&zip(&entries)).unwrap();
    for _ in 0..2 {
        let [object] = graphics(&d).try_into().unwrap();
        let InlineObject::Graphic { float, .. } = object else { panic!() };
        assert_eq!(float.spin().deg, 45.0);
        assert!(float.effect.iter().all(|v| v.abs() < 0.001), "rotation padding is not counted twice: {:?}", float.effect);
        let out = craft_docx::write(&d).unwrap();
        let files = unzip(&out);
        check_ink(&files);
        let body = text(&files, "word/document.xml");
        assert_eq!(attr_values(&body, "a:off", "x"), ["127000"]);
        assert_eq!(attr_values(&body, "a:ext", "cx"), ["914400"]);
        assert_eq!(attr_values(&body, "w14:xfrm", "rot"), ["2700000"]);
        d = craft_docx::read(&out).unwrap();
    }
}

// ---- native Word ink as a member of a group or a drawing canvas (gap 2) ----

const GROUP_URI: &str = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup";
const CANVAS_URI: &str = "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas";
const W14_NS: &str = "http://schemas.microsoft.com/office/word/2010/wordml";

/// A rectangle member `name` at `x` (EMU) in its group's space.
fn rect_member(name: &str, x: u32) -> String {
    format!(
        r#"<wps:wsp><wps:cNvPr id="{x}" name="{name}"/><wps:cNvSpPr/><wps:spPr><a:xfrm><a:off x="{x}" y="0"/><a:ext cx="914400" cy="914400"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></wps:spPr><wps:bodyPr/></wps:wsp>"#
    )
}

/// A native-ink member (`w14:contentPart`) at `x` (EMU), optionally inside `mc:AlternateContent`
/// with a picture fallback.
fn ink_member(x: u32, fallback: bool) -> String {
    let content = format!(
        r#"<w14:contentPart xmlns:w14="{W14_NS}" bwMode="auto" r:id="rInk"><w14:nvContentPartPr><w14:cNvPr id="9" name="Ink 9"/><w14:cNvContentPartPr/></w14:nvContentPartPr><w14:xfrm><a:off x="{x}" y="0"/><a:ext cx="914400" cy="457200"/></w14:xfrm></w14:contentPart>"#
    );
    if !fallback {
        return content;
    }
    format!(
        r#"<mc:AlternateContent><mc:Choice xmlns:wpi="{INK_NS}" Requires="wpi">{content}</mc:Choice><mc:Fallback><pic:pic><pic:nvPicPr><pic:cNvPr id="9" name="Ink 9"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="rPreview"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="{x}" y="0"/><a:ext cx="914400" cy="457200"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></mc:Fallback></mc:AlternateContent>"#
    )
}

/// A document whose second paragraph holds a group (or canvas) of a rectangle, `ink` and another
/// rectangle, in that order.
fn nested_ink_docx(canvas: bool, ink: &str, fallback: bool) -> Vec<u8> {
    let members = format!("{}{ink}{}", rect_member("Before", 0), rect_member("After", 1828800));
    let graphic = if canvas {
        format!(r#"<a:graphicData uri="{CANVAS_URI}"><wpc:wpc xmlns:wpc="{CANVAS_URI}"><wpc:bg/><wpc:whole/>{members}</wpc:wpc></a:graphicData>"#)
    } else {
        format!(
            r#"<a:graphicData uri="{GROUP_URI}"><wpg:wgp><wpg:cNvGrpSpPr/><wpg:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="2743200" cy="914400"/><a:chOff x="0" y="0"/><a:chExt cx="2743200" cy="914400"/></a:xfrm></wpg:grpSpPr>{members}</wpg:wgp></a:graphicData>"#
        )
    };
    let body = format!(
        r#"<w:p><w:r><w:t>Original</w:t></w:r></w:p><w:p><w:r><w:drawing><wp:inline><wp:extent cx="2743200" cy="914400"/><wp:docPr id="1" name="Group 1"/><a:graphic>{graphic}</a:graphic></wp:inline></w:drawing></w:r></w:p>"#
    );
    let mut relationships = vec![("rInk", "customXml", "ink/ink1.xml")];
    let mut extra = vec![("[Content_Types].xml", INK_TYPES), ("word/ink/ink1.xml", INK_XML)];
    if fallback {
        relationships.push(("rPreview", "image", "media/preview.png"));
        extra.push(("word/media/preview.png", "original preview bytes"));
    }
    docx(&body, &relationships, &extra)
}

/// The members of the one group or canvas in `d`.
fn group_children(d: &Document) -> Vec<craft_wordmodel::para::GroupChild> {
    let groups: Vec<_> = paras(d)
        .iter()
        .flat_map(|p| p.objects.iter())
        .filter_map(|o| match o {
            InlineObject::Group { children, .. } => Some(children.clone()),
            _ => None,
        })
        .collect();
    let [children] = groups.try_into().unwrap_or_else(|g: Vec<_>| panic!("expected one group, found {}", g.len()));
    children
}

fn assert_ink_between_rects(d: &Document) {
    let c = group_children(d);
    let kinds: Vec<_> = c
        .iter()
        .map(|c| match &c.obj {
            InlineObject::Shape { .. } => "shape",
            InlineObject::Graphic { graphic, .. } if graphic.kind.noun() == "ink" => "ink",
            _ => "other",
        })
        .collect();
    assert_eq!(kinds, ["shape", "ink", "shape"], "the ink member keeps its place among the members");
    let ink = &c[1];
    assert_eq!((ink.x, ink.y), (72.0, 0.0));
    let InlineObject::Graphic { w, h, .. } = &ink.obj else { panic!() };
    assert_eq!((*w, *h), (72.0, 36.0));
}

fn edit_first_para(d: &mut Document) {
    let p = std::sync::Arc::make_mut(&mut d.body[0]);
    let Block::Para(p) = p else { panic!() };
    p.delete(0, p.len()).unwrap();
    p.insert_text(0, "Edited", &Default::default()).unwrap();
}

#[test]
fn native_ink_in_a_group_or_canvas_survives_unrelated_edit_and_two_saves() {
    for canvas in [false, true] {
        for fallback in [false, true] {
            let what = format!("canvas {canvas}, fallback {fallback}");
            let mut d = craft_docx::read(&nested_ink_docx(canvas, &ink_member(914400, fallback), fallback)).unwrap();
            assert_ink_between_rects(&d);
            edit_first_para(&mut d);
            for _ in 0..2 {
                let out = craft_docx::write(&d).unwrap();
                let files = unzip(&out);
                check_ink(&files);
                let body = text(&files, "word/document.xml");
                assert!(body.contains("Edited"));
                let at = |s: &str| body.find(s).unwrap_or_else(|| panic!("{s} missing ({what}): {body}"));
                let ink = at("<w14:contentPart");
                assert!(at("<wps:wsp") < ink && body.rfind("<wps:wsp").unwrap() > ink, "member order lost ({what}): {body}");
                assert!(body.contains("<w14:nvContentPartPr>") && body.contains(r#"name="Ink 9""#), "{what}: {body}");
                let xfrm = &body[ink..];
                let xfrm = &xfrm[xfrm.find("<w14:xfrm").unwrap()..];
                assert_eq!(attr_values(xfrm, "a:off", "x").first().map(String::as_str), Some("914400"), "{what}");
                assert_eq!(attr_values(xfrm, "a:ext", "cx").first().map(String::as_str), Some("914400"), "{what}");
                if fallback {
                    assert!(body.contains("<mc:Fallback>"), "{what}: {body}");
                    let [id] = attr_values(&body, "a:blip", "r:embed").try_into().unwrap();
                    let (_, target) = rel(&text(&files, "word/_rels/document.xml.rels"), &id);
                    assert_eq!(text(&files, &part_at("word", &target)), "original preview bytes");
                }
                d = craft_docx::read(&out).unwrap();
                assert_ink_between_rects(&d);
            }
        }
    }
}

#[test]
fn native_ink_in_a_group_shows_its_fallback_picture() {
    let d = craft_docx::read(&nested_ink_docx(false, &ink_member(914400, true), true)).unwrap();
    let c = group_children(&d);
    let InlineObject::Graphic { graphic, .. } = &c[1].obj else { panic!() };
    assert!(
        graphic.items.iter().any(|item| matches!(item, craft_wordmodel::graphic::GraphicItem::Image { media, .. } if d.media.contains_key(media))),
        "{:?}",
        graphic.items
    );
}

#[test]
fn native_ink_in_a_nested_group_is_written_at_its_place_in_the_outer_group() {
    // The inner group doubles its members: 1 inch of its space is 2 inches of the outer group's.
    let inner = format!(
        r#"<wpg:grpSp><wpg:cNvGrpSpPr/><wpg:grpSpPr><a:xfrm><a:off x="914400" y="0"/><a:ext cx="1828800" cy="1828800"/><a:chOff x="0" y="0"/><a:chExt cx="914400" cy="914400"/></a:xfrm></wpg:grpSpPr>{}</wpg:grpSp>"#,
        ink_member(0, false)
    );
    let d = craft_docx::read(&nested_ink_docx(false, &inner, false)).unwrap();
    let c = group_children(&d);
    let ink = c.iter().find(|c| matches!(c.obj, InlineObject::Graphic { .. })).expect("ink member kept");
    let InlineObject::Graphic { w, h, .. } = &ink.obj else { panic!() };
    assert_eq!((ink.x, ink.y, *w, *h), (72.0, 0.0, 144.0, 72.0));
    let files = unzip(&craft_docx::write(&d).unwrap());
    check_ink(&files);
    let body = text(&files, "word/document.xml");
    let xfrm = &body[body.find("<w14:xfrm").unwrap()..];
    assert_eq!(attr_values(xfrm, "a:off", "x").first().map(String::as_str), Some("914400"));
    assert_eq!(attr_values(xfrm, "a:ext", "cx").first().map(String::as_str), Some("1828800"));
    assert_eq!(attr_values(xfrm, "a:ext", "cy").first().map(String::as_str), Some("914400"));
}

/// Ink parts share the custom XML relationship type with real custom XML stores: the store is
/// carried as before, the ink part only with the ink that refers to it.
#[test]
fn custom_xml_store_beside_native_ink_is_kept_and_ink_leaves_no_orphan() {
    const STORE: &str = r#"<?xml version="1.0" encoding="UTF-8"?><data xmlns="urn:example:store"><item>kept</item></data>"#;
    let types = INK_TYPES.replace("<Default ", r#"<Override PartName="/customXml/item1.xml" ContentType="application/xml"/><Default "#);
    let mut files = unzip(&nested_ink_docx(false, &ink_member(914400, false), false));
    let rels = text(&files, "word/_rels/document.xml.rels").replace(
        "</Relationships>",
        r#"<Relationship Id="rStore" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml" Target="../customXml/item1.xml"/></Relationships>"#,
    );
    files.insert("word/_rels/document.xml.rels".into(), rels.into_bytes());
    files.insert("[Content_Types].xml".into(), types.into_bytes());
    files.insert("customXml/item1.xml".into(), STORE.as_bytes().to_vec());
    let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
    let mut d = craft_docx::read(&zip(&entries)).unwrap();
    let out = unzip(&craft_docx::write(&d).unwrap());
    check_ink(&out);
    assert!(out.values().any(|b| b == STORE.as_bytes()), "the store is kept");
    assert_eq!(out.values().filter(|b| *b == INK_XML.as_bytes()).count(), 1, "one ink part, not a second copy as a store");
    // Without the ink the store stays and the ink part goes.
    d.body.truncate(1);
    let out = unzip(&craft_docx::write(&d).unwrap());
    assert!(out.values().any(|b| b == STORE.as_bytes()), "the store is kept");
    assert!(!out.values().any(|b| b == INK_XML.as_bytes()), "orphan ink part: {:?}", out.keys().collect::<Vec<_>>());
    assert!(!text(&out, "[Content_Types].xml").contains("inkml"));
    assert_eq!(text(&out, "word/_rels/document.xml.rels").matches("/customXml\"").count(), 1, "only the store's relationship");
}

#[test]
fn deleting_drawing_level_native_ink_writes_no_orphan_ink_part() {
    for fallback in [false, true] {
        let mut d = craft_docx::read(&ink_docx(fallback, false)).unwrap();
        assert_eq!(graphics(&d).len(), 1);
        d.body.truncate(1);
        let files = unzip(&craft_docx::write(&d).unwrap());
        assert!(!files.values().any(|b| b == INK_XML.as_bytes()), "orphan ink part: {:?}", files.keys().collect::<Vec<_>>());
        assert!(!text(&files, "[Content_Types].xml").contains("inkml"));
        assert!(!text(&files, "word/_rels/document.xml.rels").contains("customXml"));
    }
}

/// A group member's ink taken out of its group (not something WordCraft's commands do: Ungroup
/// refuses such a group) can't be written as a stand-alone drawing: it is left out whole, never
/// written in the wrong place, and its parts aren't written either.
#[test]
fn group_member_ink_on_its_own_is_left_out_without_orphans() {
    for fallback in [false, true] {
        let d = craft_docx::read(&nested_ink_docx(false, &ink_member(914400, fallback), fallback)).unwrap();
        let ink = group_children(&d).into_iter().find(|c| matches!(c.obj, InlineObject::Graphic { .. })).expect("ink member").obj;
        let mut d = d;
        d.body.truncate(1);
        let mut p = Paragraph::new();
        p.insert_object(0, ink, &Default::default()).unwrap();
        d.body.push(craft_wordmodel::para_block(p));
        let files = unzip(&craft_docx::write(&d).unwrap());
        let body = text(&files, "word/document.xml");
        assert!(!body.contains("contentPart"), "fallback {fallback}: {body}");
        assert!(!files.values().any(|b| b == INK_XML.as_bytes()), "orphan ink part: {:?}", files.keys().collect::<Vec<_>>());
        assert!(!text(&files, "word/_rels/document.xml.rels").contains("customXml"));
    }
}

#[test]
fn deleting_a_group_with_native_ink_writes_no_orphan_ink_part() {
    let mut d = craft_docx::read(&nested_ink_docx(false, &ink_member(914400, true), true)).unwrap();
    d.body.truncate(1);
    let files = unzip(&craft_docx::write(&d).unwrap());
    assert!(!text(&files, "word/document.xml").contains("contentPart"));
    assert!(!files.values().any(|b| b == INK_XML.as_bytes()), "orphan ink part: {:?}", files.keys().collect::<Vec<_>>());
    assert!(!text(&files, "[Content_Types].xml").contains("inkml"));
    assert!(!text(&files, "word/_rels/document.xml.rels").contains("customXml"));
}

#[test]
fn hostile_native_ink_in_a_group_never_panics() {
    // A dangling relationship, a missing part, or a part that isn't InkML: the ink member is
    // dropped (as drawing-level ink is), the other members stay.
    for fallback in [false, true] {
        for case in ["dangling", "missing", "wrong type"] {
            let mut files = unzip(&nested_ink_docx(false, &ink_member(914400, fallback), fallback));
            match case {
                "dangling" => {
                    let body = text(&files, "word/document.xml").replace(r#"r:id="rInk""#, r#"r:id="rNowhere""#);
                    files.insert("word/document.xml".into(), body.into_bytes());
                }
                "missing" => {
                    files.remove("word/ink/ink1.xml");
                }
                _ => {
                    let types = text(&files, "[Content_Types].xml").replace("application/inkml+xml", "application/xml");
                    files.insert("[Content_Types].xml".into(), types.into_bytes());
                }
            }
            let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
            let d = craft_docx::read(&zip(&entries)).unwrap();
            let c = group_children(&d);
            assert!(!c.iter().any(|c| matches!(c.obj, InlineObject::Graphic { .. })), "{case}");
            // With a picture fallback the picture takes the ink's place.
            let pictures = c.iter().filter(|c| matches!(c.obj, InlineObject::Image { .. })).count();
            assert_eq!(c.len(), if fallback { 3 } else { 2 }, "{case}, fallback {fallback}");
            assert_eq!(pictures, usize::from(fallback), "{case}");
            let out = unzip(&craft_docx::write(&d).unwrap());
            assert!(!text(&out, "word/document.xml").contains("contentPart"), "{case}");
        }
    }
    // A garbled ink part is kept as it is: InkML stays opaque.
    let mut files = unzip(&nested_ink_docx(true, &ink_member(914400, false), false));
    files.insert("word/ink/ink1.xml".into(), vec![0xff, 0x00, b'<', 0xfe]);
    let entries: Vec<_> = files.iter().map(|(name, bytes)| (name.as_str(), bytes.as_slice())).collect();
    let d = craft_docx::read(&zip(&entries)).unwrap();
    let out = unzip(&craft_docx::write(&d).unwrap());
    assert!(out.values().any(|b| b == &[0xff, 0x00, b'<', 0xfe]));
}

/// Word draws a table of contents' entry links without the Hyperlink character style (measured in
/// Word for Windows); the import drops the style from them, keeping the link. A Hyperlink-styled run
/// outside a hyperlink, and a hyperlink in another field, keep it.
#[test]
fn toc_entry_links_lose_the_hyperlink_style() {
    let styles = format!(
        r#"<w:styles {W_NS}><w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style>
        <w:style w:type="character" w:styleId="Hyperlink"><w:name w:val="Hyperlink"/><w:rPr><w:color w:val="0066FF"/><w:u w:val="single"/></w:rPr></w:style></w:styles>"#
    );
    let field = |instr: &str, inner: &str| {
        format!(
            r#"<w:p><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve">{instr}</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>{inner}</w:p><w:p><w:r><w:fldChar w:fldCharType="end"/></w:r></w:p>"#
        )
    };
    let link =
        |t: &str| format!(r#"<w:hyperlink w:anchor="_Toc1"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>{t}</w:t></w:r></w:hyperlink>"#);
    let body = [
        field(r#" TOC \o "1-3" \h \z \u "#, &link("entry")),
        field(" TOC ", r#"<w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>styled</w:t></w:r>"#),
        field(" QUOTE x ", &link("quoted")),
        format!("<w:p>{}</w:p>", link("plain")),
        r#"<w:p><w:bookmarkStart w:id="1" w:name="_Toc1"/><w:r><w:t>Target</w:t></w:r><w:bookmarkEnd w:id="1"/></w:p>"#.to_string(),
    ]
    .concat();
    let d = craft_docx::read(&docx(&body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    let run = |word: &str| {
        paras(&d).into_iter().find_map(|p| p.text.find(word).map(|at| p.props_of_char(at).clone())).unwrap_or_else(|| panic!("no run with {word}"))
    };
    let entry = run("entry");
    assert_eq!((entry.style.as_deref(), entry.link.as_deref()), (None, Some("#_Toc1")), "a TOC entry: plain, still a link");
    assert_eq!(run("styled").style.as_deref(), Some("Hyperlink"), "not in a hyperlink: kept");
    assert_eq!(run("quoted").style.as_deref(), Some("Hyperlink"), "another field: kept");
    assert_eq!(run("plain").style.as_deref(), Some("Hyperlink"), "outside fields: kept");
}

/// Localized Word (Spanish: `Hipervnculo`) and older files (`Hyperlnk`) give the built-in
/// Hyperlink character style another id; its name stays "Hyperlink". TOC entries carrying it are
/// plain too (#3239: entries showed blue).
#[test]
fn toc_entry_links_lose_a_localized_hyperlink_style() {
    for id in ["Hipervnculo", "Hyperlnk"] {
        let styles = format!(
            r#"<w:styles {W_NS}><w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style>
            <w:style w:type="character" w:styleId="{id}"><w:name w:val="Hyperlink"/><w:rPr><w:color w:val="0563C1"/><w:u w:val="single"/></w:rPr></w:style></w:styles>"#
        );
        let link = |t: &str| {
            format!(
                r#"<w:hyperlink w:anchor="_Toc1"><w:r><w:rPr><w:rStyle w:val="{id}"/></w:rPr><w:t>{t}</w:t></w:r><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> PAGEREF _Toc1 \h </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:t>1</w:t></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r></w:hyperlink>"#
            )
        };
        let body = format!(
            r#"<w:sdt><w:sdtPr><w:docPartObj><w:docPartGallery w:val="Table of Contents"/><w:docPartUnique/></w:docPartObj></w:sdtPr><w:sdtContent><w:p><w:pPr><w:pStyle w:val="TOC1"/></w:pPr><w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> TOC \o "1-3" \h \z \u </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>{}</w:p><w:p><w:r><w:fldChar w:fldCharType="end"/></w:r></w:p></w:sdtContent></w:sdt><w:p>{}</w:p><w:p><w:bookmarkStart w:id="1" w:name="_Toc1"/><w:r><w:t>Target</w:t></w:r><w:bookmarkEnd w:id="1"/></w:p>"#,
            link("entry"),
            link("plain")
        );
        let d = craft_docx::read(&docx(&body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
        let run = |word: &str| {
            paras(&d)
                .into_iter()
                .find_map(|p| p.text.find(word).map(|at| p.props_of_char(at).clone()))
                .unwrap_or_else(|| panic!("no run with {word}"))
        };
        let entry = run("entry");
        assert_eq!((entry.style.as_deref(), entry.link.as_deref()), (None, Some("#_Toc1")), "{id}: a TOC entry: plain, still a link");
        assert_eq!(run("plain").style.as_deref(), Some(id), "{id}: outside fields: kept");
    }
}

/// A style or paragraph whose `w:numPr` gives only a level (`w:ilvl`) takes the list from its
/// style chain (ECMA-376 §17.3.1.19): a Heading 3 based on a numbered Heading 2 is level 3 of the
/// same list. WordCraft dropped the level, so Heading 3s numbered as Heading 2s (6.15 where Word
/// shows 6.4.5 in NIH's monitoring-plan template).
#[test]
fn a_list_level_without_a_list_takes_the_style_s_list() {
    let styles = format!(
        r#"<w:styles {W_NS}>
        <w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style>
        <w:style w:type="paragraph" w:styleId="Heading2"><w:name w:val="heading 2"/><w:basedOn w:val="Normal"/><w:pPr><w:numPr><w:ilvl w:val="1"/><w:numId w:val="15"/></w:numPr></w:pPr></w:style>
        <w:style w:type="paragraph" w:styleId="Heading3"><w:name w:val="heading 3"/><w:basedOn w:val="Heading2"/><w:pPr><w:numPr><w:ilvl w:val="2"/></w:numPr></w:pPr></w:style>
        <w:style w:type="paragraph" w:styleId="Heading4"><w:name w:val="heading 4"/><w:basedOn w:val="Heading3"/><w:pPr><w:numPr><w:ilvl w:val="3"/></w:numPr></w:pPr></w:style>
        <w:style w:type="paragraph" w:styleId="Loose"><w:name w:val="Loose"/><w:basedOn w:val="Normal"/><w:pPr><w:numPr><w:ilvl w:val="4"/></w:numPr></w:pPr></w:style>
        </w:styles>"#
    );
    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading3"/></w:pPr><w:r><w:t>three</w:t></w:r></w:p>
        <w:p><w:pPr><w:pStyle w:val="Heading2"/><w:numPr><w:ilvl w:val="2"/></w:numPr></w:pPr><w:r><w:t>direct level</w:t></w:r></w:p>
        <w:p><w:pPr><w:numPr><w:ilvl w:val="1"/></w:numPr></w:pPr><w:r><w:t>no list anywhere</w:t></w:r></w:p>"#;
    let d = craft_docx::read(&docx(body, &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    let num = |id: &str| d.styles.get(id).and_then(|s| s.para.numbering).map(|n| (n.num, n.level));
    assert_eq!(num("Heading3"), Some((15, 2)), "Heading 3 is level 3 of Heading 2's list");
    assert_eq!(num("Heading4"), Some((15, 3)), "through two level-only styles");
    assert_eq!(num("Loose"), None, "no list in the chain: no numbering");
    let p = paras(&d);
    assert_eq!(d.styles.resolve_para(&p[0].props).numbering.map(|n| (n.num, n.level)), Some((15, 2)));
    assert_eq!(p[1].props.numbering.map(|n| (n.num, n.level)), Some((15, 2)), "a paragraph's own level, its style's list");
    assert_eq!(p[2].props.numbering, None);
    // Saved and read again it is an ordinary list reference.
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(again.styles.get("Heading3").and_then(|s| s.para.numbering).map(|n| (n.num, n.level)), Some((15, 2)));
}

/// `w:hideMark` on a cell is read and written back (it was dropped, and the empty rows NIH's
/// tables collapse with it showed as blank lines).
#[test]
fn cell_hide_mark_reads_and_round_trips() {
    let body = r#"<w:tbl><w:tblGrid><w:gridCol w:w="2000"/><w:gridCol w:w="2000"/></w:tblGrid><w:tr><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/><w:hideMark/></w:tcPr><w:p/></w:tc><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr><w:p/></w:tc></w:tr></w:tbl><w:p/>"#;
    let hides = |d: &Document| -> Vec<bool> {
        d.body
            .iter()
            .find_map(|b| {
                if let craft_wordmodel::Block::Table(t) = &**b { Some(t.rows[0].cells.iter().map(|c| c.props.hide_mark).collect()) } else { None }
            })
            .unwrap()
    };
    let d = read_body(body);
    assert_eq!(hides(&d), [true, false]);
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(hides(&again), [true, false]);
}

/// Text frames (`w:framePr` without a drop cap), as NIH's templates put a footer's page number in
/// one: read with their size, anchors, alignment and wrap, and written back (they were dropped on
/// save).
#[test]
fn text_frames_read_and_round_trip() {
    let body = r#"<w:p><w:pPr><w:framePr w:wrap="around" w:vAnchor="text" w:hAnchor="margin" w:xAlign="center" w:y="1"/></w:pPr><w:r><w:t>3</w:t></w:r></w:p>
        <w:p><w:pPr><w:framePr w:w="2880" w:h="720" w:hRule="exact" w:hSpace="180" w:wrap="notBeside" w:hAnchor="page" w:vAnchor="page" w:x="1440" w:y="2880"/></w:pPr><w:r><w:t>boxed</w:t></w:r></w:p>
        <w:p><w:pPr><w:framePr w:wrap="sideways" w:hAnchor="nowhere" w:w="-5" w:x="NaN"/></w:pPr><w:r><w:t>junk</w:t></w:r></w:p>
        <w:p><w:pPr><w:framePr w:dropCap="drop" w:lines="2" w:wrap="around" w:vAnchor="text" w:hAnchor="text"/></w:pPr><w:r><w:t>D</w:t></w:r></w:p>
        <w:p><w:r><w:t>rop cap text</w:t></w:r></w:p>"#;
    let d = read_body(body);
    let p = paras(&d);
    let f = p[0].props.frame.clone().expect("a frame");
    assert_eq!(
        (f.wrap.as_str(), f.v_anchor.as_str(), f.h_anchor.as_str(), f.x_align.as_deref(), f.y),
        ("around", "text", "margin", Some("center"), 0.05)
    );
    let g = p[1].props.frame.clone().expect("a frame");
    assert_eq!((g.w, g.h, g.h_exact, g.h_space, g.wrap.as_str(), g.x, g.y), (Some(144.0), Some(36.0), true, 9.0, "notBeside", 72.0, 144.0));
    let cap = p.iter().find(|q| q.props.drop_cap.is_some()).expect("the drop cap");
    assert!(cap.props.frame.is_none(), "a drop cap stays a drop cap");
    let junk = p.iter().find(|q| q.text.contains("junk")).and_then(|q| q.props.frame.clone()).expect("a frame");
    assert_eq!((junk.wrap.as_str(), junk.h_anchor.as_str(), junk.w, junk.x), ("auto", "page", None, 0.0), "unknown values fall back");
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    let q = paras(&again);
    assert_eq!(q[0].props.frame, p[0].props.frame);
    assert_eq!(q[1].props.frame, p[1].props.frame);
    assert!(q.iter().any(|x| x.props.drop_cap == Some(2) && x.props.frame.is_none()));
}

/// #2360: a `w:framePr` in the document defaults, the sizeless top-left one Apple Pages writes,
/// frames no paragraph, as in Word: a header's title and the body's text stay in the text instead
/// of moving to the page's corner, and the default isn't written back. The defaults' other
/// properties are kept, and a style's own frame still applies.
#[test]
fn a_frame_in_the_paragraph_defaults_frames_nothing() {
    let styles = format!(
        r#"<w:styles {W_NS}><w:docDefaults><w:pPrDefault><w:pPr><w:framePr w:anchorLock="0" w:w="0" w:h="0" w:vSpace="0" w:hSpace="0" w:xAlign="left" w:y="0" w:hRule="exact" w:vAnchor="margin"/><w:spacing w:after="120"/></w:pPr></w:pPrDefault></w:docDefaults><w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style><w:style w:type="paragraph" w:styleId="Framed"><w:name w:val="Framed"/><w:pPr><w:framePr w:wrap="around" w:hAnchor="margin" w:vAnchor="text" w:xAlign="right" w:y="1"/></w:pPr></w:style></w:styles>"#
    );
    let header = format!(r#"<w:hdr {W_NS}><w:p><w:r><w:t>Title</w:t></w:r></w:p></w:hdr>"#);
    let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:p><w:pPr><w:pStyle w:val="Framed"/></w:pPr><w:r><w:t>Boxed</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/></w:sectPr>"#;
    let bytes = docx(
        body,
        &[("rIdS", "styles", "styles.xml"), ("rIdH", "header", "header1.xml")],
        &[("word/styles.xml", &styles), ("word/header1.xml", &header)],
    );
    let check = |d: &Document| {
        assert!(d.styles.default_para.frame.is_none(), "{:?}", d.styles.default_para.frame);
        assert_eq!(d.styles.default_para.space_after, Some(6.0), "the defaults' spacing is kept");
        let frame = |p: &Paragraph| d.styles.resolve_para(&p.props).frame;
        let body = paras(d);
        assert_eq!(body[0].text, "Body");
        assert!(frame(body[0]).is_none(), "body text is not a frame");
        let boxed = frame(body[1]).expect("a style's frame still applies");
        assert_eq!((boxed.h_anchor.as_str(), boxed.x_align.as_deref()), ("margin", Some("right")));
        let hid = d.last_section.headers.default.expect("a header");
        let title = d.parts.get(&hid).unwrap().blocks.iter().find_map(|b| b.as_para()).expect("the title");
        assert_eq!(title.text, "Title");
        assert!(frame(title).is_none(), "the header's title is not a frame");
    };
    let d = craft_docx::read(&bytes).unwrap();
    check(&d);
    let saved = craft_docx::write(&d).unwrap();
    let xml = text(&unzip(&saved), "word/styles.xml");
    let defaults = xml.split("</w:docDefaults>").next().unwrap_or_default();
    assert!(!defaults.contains("w:framePr"), "the default frame isn't written back: {defaults}");
    check(&craft_docx::read(&saved).unwrap());
}

/// A legacy VML freeform (`v:shape` with a `path`, ECMA-376 Part 4): a rule across a header,
/// drawn in a 1000 × 1000 coordinate space, outlined, its fill transparent. It is read as a
/// freeform of the shape's size and kept when saved (as DrawingML custom geometry) and read back.
#[test]
fn vml_freeform_rule_in_header() {
    let w10 = r#"xmlns:w10="urn:schemas-microsoft-com:office:word""#;
    let rule = r##"<w:p><w:r><w:pict><v:shape style="position:absolute;margin-left:0;margin-top:30pt;width:360pt;height:12pt;z-index:2;mso-position-horizontal-relative:margin;mso-position-vertical-relative:margin" coordsize="1000,1000" path="m,500l1000,500xe" fillcolor="this" stroked="t" strokecolor="#3366cc" strokeweight="1.5pt"><v:fill opacity="0"/><w10:wrap anchorx="margin"/></v:shape></w:pict></w:r>
<w:r><w:pict><v:shape style="width:20pt;height:10pt" coordorigin="100,100" coordsize="200,100" path="t100,100r100,0,0,100nfx e" strokecolor="red"><v:stroke opacity="32768f"/></v:shape></w:pict></w:r></w:p>"##;
    let header = format!(r#"<w:hdr {W_NS} {w10}><w:p><w:r><w:t>Header</w:t></w:r></w:p>{rule}</w:hdr>"#);
    let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rIdH"/></w:sectPr>"#;
    let bytes = docx(body, &[("rIdH", "header", "header1.xml")], &[("word/header1.xml", &header)]);
    let near = |a: f32, b: f32| (a - b).abs() < 0.05;
    let check = |d: &Document| {
        let hid = d.last_section.headers.default.unwrap();
        let shapes: Vec<&InlineObject> = d.parts.get(&hid).unwrap().blocks.iter().filter_map(|b| b.as_para()).flat_map(|p| &p.objects).collect();
        let [rule, tri] = shapes.as_slice() else { panic!("{shapes:?}") };
        let InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, freeform: Some(f), .. } = rule else { panic!("{rule:?}") };
        assert_eq!((*kind, fill.as_ref().map(Fill::main_color), *stroke), (ShapeKind::Freeform, None, Some(Rgb(0x33, 0x66, 0xCC))));
        assert!(near(*w, 360.0) && near(*h, 12.0) && near(*stroke_width, 1.5), "{w} x {h}, {stroke_width}");
        assert_eq!((float.h_rel, float.v_rel, float.wrap), (Anchor::Margin, Anchor::Margin, Wrap::InFrontOfText));
        assert!(near(float.y, 30.0), "{float:?}");
        let [p] = f.paths.as_slice() else { panic!("{f:?}") };
        let pts = f.placed(0.0, 0.0, *w, *h);
        let [(pts, _)] = pts.as_slice() else { panic!("{pts:?}") };
        assert!(p.closed && pts.len() == 2, "{pts:?}");
        assert!(near(pts[0][0], 0.0) && near(pts[0][1], 6.0) && near(pts[1][0], 360.0) && near(pts[1][1], 6.0), "{pts:?}");
        // Relative moves and lines from the origin, `nf`: an outlined triangle, half opaque.
        let InlineObject::Shape { kind: ShapeKind::Freeform, fill: None, stroke: Some(Rgb(255, 0, 0)), w, h, freeform: Some(f), .. } = tri else {
            panic!("{tri:?}")
        };
        let placed = f.placed(0.0, 0.0, *w, *h);
        let [(pts, true)] = placed.as_slice() else { panic!("{placed:?}") };
        let want = [[0.0, 0.0], [10.0, 0.0], [10.0, 10.0]];
        assert!(pts.len() == 3 && pts.iter().zip(want).all(|(a, b)| near(a[0], b[0]) && near(a[1], b[1])), "{pts:?}");
        assert!(near(f.alpha, 0.5), "{}", f.alpha);
    };
    let d = craft_docx::read(&bytes).unwrap();
    check(&d);
    check(&craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap());
}

/// Hostile VML paths and coordinate spaces read without panicking and stay finite.
#[test]
fn hostile_vml_paths_stay_finite() {
    let paths = [
        "m,",
        "l",
        "mxe",
        "m99999999999999999999999999,0l-99999999999999999999,1e",
        "minf,nanlNaN,-inf",
        "m@1,@2l@3,@4nfnse",
        "wa1",
        "c1",
        "m١٢,٣l٤,٥",
        "m0,0c",
        "m0,0v1,2,3",
        "ar0,0,10,10,0,0,10,10at",
        "m0,0r1,1,1,1,1,1,1,1,1,1x x x l",
        "--..,,@@ ,,, xm1.5.5,2..3l+-+,-e",
        "\u{1F600}m1,1l2,2",
        "qbqxqyaeal1,2,3,4,5,6",
    ];
    let spaces = [("0,0", "0,0"), ("-5,-5", "x,y"), ("1e39,x", "-99999999999999999999,99999999999999999999"), ("", ""), ("1,1", "1e308,1e308")];
    for path in paths {
        for (size, origin) in spaces {
            let body = format!(
                r#"<w:p><w:r><w:pict><v:shape style="width:1e30pt;height:-4pt" coordsize="{size}" coordorigin="{origin}" path="{path}" strokecolor="black"/></w:pict></w:r></w:p>"#
            );
            let d = read_body(&body);
            // A path with formulas isn't drawn (they aren't evaluated).
            if path.contains('@') {
                assert!(paras(&d)[0].objects.iter().all(|o| !matches!(o, InlineObject::Shape { freeform: Some(_), .. })), "{path}");
            }
            for o in &paras(&d)[0].objects {
                if let InlineObject::Shape { w, h, freeform: Some(f), .. } = o {
                    assert!(w.is_finite() && h.is_finite() && f.alpha.is_finite(), "{path}");
                    assert!(f.paths.iter().flat_map(|p| &p.pts).all(|[x, y]| x.is_finite() && y.is_finite()), "{path} {size} {origin}");
                    for (pts, _) in f.placed(0.0, 0.0, *w, *h) {
                        assert!(pts.iter().all(|[x, y]| x.is_finite() && y.is_finite()), "{path}");
                    }
                }
            }
            craft_docx::write(&d).unwrap();
        }
    }
}

/// Measured in Word for Mac: a `majorBidi`/`minorBidi` theme slot names the theme's font for the
/// script of the settings' `w:themeFontLang/@w:bidi` (the Latin font for a Latin language), else
/// the theme's `a:cs`, else Times New Roman; with no bidi language there, Times New Roman whatever
/// the theme says. The run's own `w:lang` and the inherited fonts play no part. Papers set in
/// `majorBidi` with Office's usual theme (`Arab` → Times New Roman) came out in Calibri Light.
#[test]
fn bidi_theme_slots_follow_the_theme_font_language() {
    let tnr = "Times New Roman";
    // (themeFontLang, a:cs, Arab entries present, run lang) → (majorBidi, minorBidi)
    let cases: &[(Option<&str>, &str, bool, &str, [&str; 2])] = &[
        (None, "", true, "", [tnr, tnr]),
        (None, "Arial", true, r#"<w:lang w:bidi="ar-SA"/>"#, [tnr, tnr]),
        (Some(r#"w:val="en-US""#), "Arial", true, "", [tnr, tnr]),
        (Some(r#"w:bidi="ar-SA""#), "", true, r#"<w:lang w:bidi="he-IL"/>"#, ["Georgia", "Trebuchet MS"]),
        (Some(r#"w:bidi="ar-SA""#), "Arial", true, "", ["Georgia", "Trebuchet MS"]),
        (Some(r#"w:bidi="he-IL""#), "", true, "", ["Courier New", "Comic Sans MS"]),
        (Some(r#"w:bidi="ur-PK""#), "Arial", true, "", ["Georgia", "Trebuchet MS"]),
        (Some(r#"w:bidi="pa-PK""#), "Arial", true, "", ["Georgia", "Trebuchet MS"]),
        (Some(r#"w:bidi="pa-IN""#), "Arial", true, "", ["Arial", "Arial"]),
        (Some(r#"w:bidi="fr-FR""#), "Arial", true, "", ["Verdana", "Impact"]),
        (Some(r#"w:bidi="th-TH""#), "Arial", true, "", ["Arial", "Arial"]),
        (Some(r#"w:bidi="th-TH""#), "", true, "", [tnr, tnr]),
        (Some(r#"w:bidi="ar-SA""#), "Arial", false, "", ["Arial", "Arial"]),
    ];
    for (i, (lang, cs, arab, run_lang, want)) in cases.iter().enumerate() {
        let script = |f: &str| if *arab { format!(r#"<a:font script="Arab" typeface="{f}"/>"#) } else { String::new() };
        let theme = format!(
            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="T"><a:themeElements><a:fontScheme name="F"><a:majorFont><a:latin typeface="Verdana"/><a:ea typeface=""/><a:cs typeface="{cs}"/>{}<a:font script="Hebr" typeface="Courier New"/></a:majorFont><a:minorFont><a:latin typeface="Impact"/><a:ea typeface=""/><a:cs typeface="{cs}"/>{}<a:font script="Hebr" typeface="Comic Sans MS"/></a:minorFont></a:fontScheme></a:themeElements></a:theme>"#,
            script("Georgia"),
            script("Trebuchet MS")
        );
        let font_lang = lang.map(|l| format!("<w:themeFontLang {l}/>")).unwrap_or_default();
        let settings = format!(r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:settings {W_NS}>{font_lang}</w:settings>"#);
        let styles = format!(
            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:styles {W_NS}><w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="Andale Mono" w:hAnsi="Andale Mono" w:cs="Andale Mono"/><w:lang w:val="en-US" w:bidi="ar-SA"/></w:rPr></w:rPrDefault></w:docDefaults></w:styles>"#
        );
        let run = |slot: &str| {
            format!(r#"<w:p><w:r><w:rPr><w:rFonts w:asciiTheme="{slot}" w:hAnsiTheme="{slot}"/>{run_lang}</w:rPr><w:t>x</w:t></w:r></w:p>"#)
        };
        let body = [run("majorBidi"), run("minorBidi"), run("majorHAnsi")].concat();
        let rels = [
            ("rId7", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", "settings.xml"),
            ("rId8", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles", "styles.xml"),
            ("rId9", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme", "theme/theme1.xml"),
        ];
        let parts = [("word/theme/theme1.xml", theme.as_str()), ("word/settings.xml", settings.as_str()), ("word/styles.xml", styles.as_str())];
        let d = craft_docx::read(&docx(&body, &rels, &parts)).unwrap();
        let fonts: Vec<_> = paras(&d).iter().map(|p| p.runs[0].props.font.clone().unwrap_or_default()).collect();
        assert_eq!(fonts, [want[0], want[1], "Verdana"], "case {i}");
    }
}

/// A `w:rFonts` fallback list longer than the reader keeps is cut at the last complete family
/// within the bound, so the family a real list would pick survives while a hostile list cannot
/// cost its whole length in every piece of text drawn in it.
#[test]
fn a_hostile_fallback_list_keeps_its_leading_families() {
    let candidates: Vec<String> = (0..500).map(|i| format!("MissingCandidateFont{i}")).collect();
    let list = format!("{};Source Serif 4", candidates.join(";"));
    let body = format!(r#"<w:p><w:r><w:rPr><w:rFonts w:ascii="{list}" w:hAnsi="{list}"/></w:rPr><w:t>x</w:t></w:r></w:p>"#);
    let d = read_body(&body);
    let c = &d.body[0].as_para().unwrap().runs[0].props;
    let kept = c.font.as_deref().expect("the leading families are kept");
    assert!(kept.len() <= 256, "{} bytes kept", kept.len());
    assert!(kept.starts_with("MissingCandidateFont0"), "{kept}");
    // Every kept entry is a whole family name: the cut lands on a `;`, never inside a name.
    assert!(kept.split(';').all(|f| f.starts_with("MissingCandidateFont") || f.contains("Source Serif")), "{kept}");
    assert!(!kept.ends_with(';'), "no dangling separator: {kept}");
}

/// A real LibreOffice fallback list is read whole: a few families, well under any bound.
#[test]
fn a_real_fallback_list_is_read_whole() {
    let body = r#"<w:p><w:r><w:rPr><w:rFonts w:ascii="Liberation Sans;Arial" w:hAnsi="Liberation Sans;Arial"/></w:rPr><w:t>x</w:t></w:r></w:p>"#;
    let d = read_body(body);
    let c = &d.body[0].as_para().unwrap().runs[0].props;
    assert_eq!(c.font.as_deref(), Some("Liberation Sans;Arial"));
}

/// The font table's family classes: Word draws a missing roman font in a serif face.
#[test]
fn roman_fonts_are_read_from_the_font_table() {
    let fonts = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:fonts xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:font w:name="Brand Serif"><w:family w:val="roman"/></w:font><w:font w:name="Brand Sans"><w:family w:val="swiss"/></w:font></w:fonts>"#;
    let rels = [("rId9", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable", "fontTable.xml")];
    let d = craft_docx::read(&docx("<w:p/>", &rels, &[("word/fontTable.xml", fonts)])).unwrap();
    assert_eq!(d.settings.roman_fonts, ["Brand Serif"]);
}

/// Semicolon-separated roman font fallback lists in `fontTable.xml` register each candidate family.
#[test]
fn roman_fonts_split_fallback_lists() {
    let fonts = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:fonts xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:font w:name="Liberation Serif;Times New Roman"><w:family w:val="roman"/></w:font></w:fonts>"#;
    let rels = [("rId9", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable", "fontTable.xml")];
    let d = craft_docx::read(&docx("<w:p/>", &rels, &[("word/fontTable.xml", fonts)])).unwrap();
    assert_eq!(d.settings.roman_fonts, ["Liberation Serif", "Times New Roman"]);
}

/// `w:doNotUseHTMLParagraphAutoSpacing` in the settings' `w:compat`: paragraph spacing adds up.
#[test]
fn html_auto_spacing_off_is_read_and_kept() {
    let settings = |compat: &str| {
        let s = format!(r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:settings {W_NS}><w:compat>{compat}</w:compat></w:settings>"#);
        let rels = [("rId9", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", "settings.xml")];
        let d = craft_docx::read(&docx("<w:p/>", &rels, &[("word/settings.xml", &s)])).unwrap();
        let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
        (d.settings.sum_paragraph_spacing, again.settings.sum_paragraph_spacing)
    };
    assert_eq!(settings("<w:doNotUseHTMLParagraphAutoSpacing/>"), (true, true));
    assert_eq!(settings(""), (false, false));
}

/// `w:doNotExpandShiftReturn` in the settings' `w:compat`: justified lines ending in a manual line
/// break keep their spacing (#3924).
#[test]
fn do_not_expand_shift_return_is_read_and_kept() {
    let settings = |compat: &str| {
        let s = format!(r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:settings {W_NS}><w:compat>{compat}</w:compat></w:settings>"#);
        let rels = [("rId9", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", "settings.xml")];
        let d = craft_docx::read(&docx("<w:p/>", &rels, &[("word/settings.xml", &s)])).unwrap();
        let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
        (d.settings.do_not_expand_shift_return, again.settings.do_not_expand_shift_return)
    };
    assert_eq!(settings("<w:doNotExpandShiftReturn/>"), (true, true));
    assert_eq!(settings(r#"<w:doNotExpandShiftReturn w:val="0"/>"#), (false, false));
    assert_eq!(settings(""), (false, false));
}

/// A right triangle (`rtTriangle`) has its right angle at the bottom left: a cover page's white
/// corner cut-outs drawn as isosceles triangles pointed the wrong way.
#[test]
fn a_right_triangle_keeps_its_right_angle() {
    let body = anchored_wsp("Corner", 1270000, 635000, r#"<a:prstGeom prst="rtTriangle"><a:avLst/></a:prstGeom>"#, "", "<wps:cNvSpPr/>");
    let d = read_body(&format!("<w:p>{body}</w:p>"));
    let kind = |d: &Document| match &paras(d)[0].objects[0] {
        InlineObject::Shape { kind, .. } => *kind,
        o => panic!("{o:?}"),
    };
    assert_eq!(kind(&d), ShapeKind::RightTriangle);
    let saved = craft_docx::write(&d).unwrap();
    assert_eq!(kind(&craft_docx::read(&saved).unwrap()), ShapeKind::RightTriangle);
}

#[test]
fn hyperlink_with_empty_target_is_no_link() {
    // LibreOffice writes `Target=""` for the Hyperlink character style without an address (#1005).
    let body = r#"<w:p><w:hyperlink r:id="rId2"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>plain</w:t></w:r></w:hyperlink><w:hyperlink r:id="rId3"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>mail</w:t></w:r></w:hyperlink><w:hyperlink w:anchor="top"><w:r><w:t>jump</w:t></w:r></w:hyperlink></w:p>"#;
    let bytes = docx(body, &[("rId2", "hyperlink", "https://x"), ("rId3", "hyperlink", "mailto:a@example.com")], &[]);
    // Blank the first target and mark the mailto one external (the helper only does that for http).
    let bytes = {
        let mut zr = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
        let mut entries = Vec::new();
        for i in 0..zr.len() {
            let mut f = zr.by_index(i).unwrap();
            let mut buf = Vec::new();
            std::io::Read::read_to_end(&mut f, &mut buf).unwrap();
            if f.name().unwrap() == "word/_rels/document.xml.rels" {
                buf = String::from_utf8(buf)
                    .unwrap()
                    .replace("Target=\"https://x\"", "Target=\"\"")
                    .replace("a@example.com\"", "a@example.com\" TargetMode=\"External\"")
                    .into_bytes();
            }
            entries.push((f.name().unwrap().to_string(), buf));
        }
        let refs: Vec<(&str, &[u8])> = entries.iter().map(|(n, b)| (n.as_str(), b.as_slice())).collect();
        zip(&refs)
    };
    let doc = craft_docx::read(&bytes).unwrap();
    let p = doc.body.iter().find_map(|b| b.as_para()).unwrap();
    assert_eq!(p.plain_text(), "plainmailjump");
    assert_eq!(p.props_of_char(0).link, None);
    assert_eq!(p.props_of_char(0).style.as_deref(), Some("Hyperlink"));
    assert_eq!(p.props_of_char(5).link.as_deref(), Some("mailto:a@example.com"));
    assert_eq!(p.props_of_char(9).link.as_deref(), Some("#top"));
    // Round trip keeps exactly the real links.
    let back = craft_docx::read(&craft_docx::write(&doc).unwrap()).unwrap();
    let p = back.body.iter().find_map(|b| b.as_para()).unwrap();
    assert_eq!(p.props_of_char(0).link, None);
    assert_eq!(p.props_of_char(5).link.as_deref(), Some("mailto:a@example.com"));
}

/// Picture brightness, contrast and transparency (#1711, #1766): VML `gain`/`blacklevel` (Word's
/// watermark "Washout"), DrawingML `a:lum` and `a:alphaModFix`; saved as DrawingML and read back.
#[test]
fn picture_brightness_contrast_transparency() {
    use craft_wordmodel::picfx::PicFx;
    let png: &[u8] = b"\x89PNG\r\n\x1a\nnot really a png";
    let vml =
        |attrs: &str| format!(r#"<w:r><w:pict><v:shape style="width:1in;height:36pt"><v:imagedata r:id="rIdImg" {attrs}/></v:shape></w:pict></w:r>"#);
    let dml = |blip: &str| {
        format!(
            r#"<w:r><w:drawing><wp:inline><wp:extent cx="1270000" cy="635000"/><wp:docPr id="3" name="P"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rIdImg">{blip}</a:blip></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#
        )
    };
    let cases: Vec<(String, Option<PicFx>)> = vec![
        // Word's Washout: 0.3 and 0.35 in 16.16 fixed point.
        (vml(r#"gain="19661f" blacklevel="22938f""#), Some(PicFx::new(70_000, -70_000, 0))),
        (vml(r#"gain="0.5" blacklevel="0.25""#), Some(PicFx::new(50_000, -50_000, 0))),
        (vml(r#"gain="131072f""#), Some(PicFx::new(0, 50_000, 0))),
        (vml(""), Some(PicFx::default())),
        (dml(r#"<a:lum bright="80000" contrast="-80000"/>"#), Some(PicFx::new(80_000, -80_000, 0))),
        (dml(r#"<a:alphaModFix amt="40000"/><a:lum bright="-20000"/>"#), Some(PicFx::new(-20_000, 0, 60_000))),
        (dml(""), Some(PicFx::default())),
        // Hostile values: clamped, never a panic.
        (vml(r#"gain="NaNf" blacklevel="infinity""#), None),
        (vml(r#"gain="-99999999f" blacklevel="99999999999f""#), None),
        (vml(r#"gain="1e308" blacklevel="-1e308""#), None),
        (vml(r#"gain="f" blacklevel="--3""#), None),
        (dml(r#"<a:lum bright="999999999" contrast="-99999999999999999999"/><a:alphaModFix amt="-5"/>"#), None),
        (dml(r#"<a:alphaModFix amt="250000"/><a:lum bright="x" contrast=""/>"#), None),
    ];
    let body: String = cases.iter().map(|(x, _)| format!("<w:p>{x}</w:p>")).collect();
    let doc = format!(r#"<w:document {W_NS}><w:body>{body}</w:body></w:document>"#);
    let r = rels(&[("rIdImg", "image", "media/pic.png")]);
    let bytes = zip(&[
        ("_rels/.rels", ROOT_RELS.as_bytes()),
        ("word/document.xml", doc.as_bytes()),
        ("word/_rels/document.xml.rels", r.as_bytes()),
        ("word/media/pic.png", png),
    ]);
    let d = craft_docx::read(&bytes).unwrap();
    let fx_of = |d: &Document| -> Vec<PicFx> {
        paras(d)
            .iter()
            .map(|p| match p.objects.first() {
                Some(InlineObject::Image { fx, .. }) => *fx,
                o => panic!("{o:?}"),
            })
            .collect()
    };
    let read = fx_of(&d);
    assert_eq!(read.len(), cases.len());
    for ((x, want), got) in cases.iter().zip(&read) {
        assert_eq!(*got, got.clamped(), "{x}");
        if let Some(want) = want {
            let near = |a: i32, b: i32| (a - b).abs() <= 2;
            assert!(near(got.bright, want.bright) && near(got.contrast, want.contrast) && got.transparency == want.transparency, "{x}: {got:?}");
        }
    }
    // Clamped hostile values.
    assert_eq!(read[11], PicFx::new(100_000, -100_000, 100_000));
    assert_eq!(read[12], PicFx::default());
    // Saved as DrawingML (VML pictures too) and read back unchanged.
    let out = craft_docx::write(&d).unwrap();
    let back = craft_docx::read(&out).unwrap();
    assert_eq!(fx_of(&back), read);
}

/// Word's picture watermark with Washout (#1711): a VML picture in a header's Watermarks
/// building block keeps its brightness and contrast.
#[test]
fn washout_picture_watermark_in_header() {
    let hdr = format!(
        r##"<w:hdr {W_NS}><w:sdt><w:sdtPr><w:docPartObj><w:docPartGallery w:val="Watermarks"/><w:docPartUnique/></w:docPartObj></w:sdtPr><w:sdtContent><w:p><w:r><w:pict><v:shape id="WordPictureWatermark1" type="#_x0000_t75" style="position:absolute;margin-left:0;margin-top:0;width:200pt;height:200pt;z-index:-251657216;mso-position-horizontal:center;mso-position-horizontal-relative:margin;mso-position-vertical:center;mso-position-vertical-relative:margin"><v:imagedata r:id="rImg" o:title="wm" gain="19661f" blacklevel="22938f"/></v:shape></w:pict></w:r></w:p></w:sdtContent></w:sdt></w:hdr>"##
    );
    let hrels = rels(&[("rImg", "image", "media/wm.png")]);
    let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rHdr"/></w:sectPr>"#;
    let d = craft_docx::read(&docx(
        body,
        &[("rHdr", "header", "header1.xml")],
        &[("word/header1.xml", &hdr), ("word/_rels/header1.xml.rels", &hrels), ("word/media/wm.png", "not really a png")],
    ))
    .unwrap();
    let id = d.last_section.headers.default.unwrap();
    let fx = d.parts[&id]
        .blocks
        .iter()
        .filter_map(|b| b.as_para())
        .flat_map(|p| p.objects.iter())
        .find_map(|o| if let InlineObject::Image { fx, .. } = o { Some(*fx) } else { None })
        .expect("watermark picture");
    assert!((fx.bright - 70_000).abs() <= 2 && (fx.contrast + 70_000).abs() <= 2, "{fx:?}");
}

/// A faded DrawingML picture behind a header's text (#1766; #1961 review): `a:alphaModFix` reads
/// and is written back once, as in the body.
#[test]
fn faded_picture_behind_text_in_header() {
    let hdr = format!(
        r#"<w:hdr {W_NS}><w:p><w:r><w:drawing><wp:anchor behindDoc="1" distT="0" distB="0" distL="0" distR="0" simplePos="0" relativeHeight="1" locked="0" layoutInCell="1" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="margin"><wp:align>center</wp:align></wp:positionH><wp:positionV relativeFrom="margin"><wp:align>center</wp:align></wp:positionV><wp:extent cx="2540000" cy="2540000"/><wp:wrapNone/><wp:docPr id="7" name="Faded"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rImg"><a:alphaModFix amt="20000"/></a:blip></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:anchor></w:drawing></w:r></w:p></w:hdr>"#
    );
    let hrels = rels(&[("rImg", "image", "media/wm.png")]);
    let body = r#"<w:p><w:r><w:t>Body</w:t></w:r></w:p><w:sectPr><w:headerReference w:type="default" r:id="rHdr"/></w:sectPr>"#;
    let header_picture = |d: &craft_wordmodel::Document| {
        let id = d.last_section.headers.default.unwrap();
        d.parts[&id]
            .blocks
            .iter()
            .filter_map(|b| b.as_para())
            .flat_map(|p| p.objects.iter())
            .find_map(|o| if let InlineObject::Image { fx, float, .. } = o { Some((*fx, float.wrap)) } else { None })
            .expect("header picture")
    };
    let d = craft_docx::read(&docx(
        body,
        &[("rHdr", "header", "header1.xml")],
        &[("word/header1.xml", &hdr), ("word/_rels/header1.xml.rels", &hrels), ("word/media/wm.png", "not really a png")],
    ))
    .unwrap();
    let (fx, wrap) = header_picture(&d);
    assert_eq!(fx, craft_wordmodel::picfx::PicFx::new(0, 0, 80_000));
    assert_eq!(wrap, craft_wordmodel::para::Wrap::BehindText);
    let saved = craft_docx::write(&d).unwrap();
    let again = craft_docx::read(&saved).unwrap();
    assert_eq!(header_picture(&again), (fx, wrap), "the same picture after saving");
}

/// An OLE object's preview keeps the corrections of its picture (#1961 review).
#[test]
fn ole_preview_keeps_its_corrections() {
    let body = r##"<w:p><w:r><w:object w:dxaOrig="1440" w:dyaOrig="720"><v:shape id="_x0000_i1025" type="#_x0000_t75" style="width:72pt;height:36pt" o:ole=""><v:imagedata r:id="rIdImg" gain="19661f" blacklevel="22938f"/></v:shape></w:object></w:r></w:p>"##;
    let d = craft_docx::read(&docx(body, &[("rIdImg", "image", "media/p.png")], &[("word/media/p.png", "not really a png")])).unwrap();
    let fx = d.body[0]
        .as_para()
        .and_then(|p| p.objects.iter().find_map(|o| if let InlineObject::Image { fx, .. } = o { Some(*fx) } else { None }))
        .expect("the preview");
    assert!((fx.bright - 70_000).abs() <= 2 && (fx.contrast + 70_000).abs() <= 2, "{fx:?}");
}

#[test]
fn row_table_borders_round_trip() {
    let d = read_body(
        r#"<w:tbl><w:tblPr/><w:tblGrid><w:gridCol w:w="2000"/><w:gridCol w:w="2000"/></w:tblGrid>
<w:tr><w:tblPrEx><w:tblBorders><w:top w:val="single" w:sz="8"/><w:insideV w:val="single" w:sz="4"/></w:tblBorders></w:tblPrEx>
<w:trPr><w:trHeight w:val="400"/></w:trPr><w:tc><w:p/></w:tc><w:tc><w:p/></w:tc></w:tr>
<w:tr><w:tc><w:p/></w:tc><w:tc><w:p/></w:tc></w:tr></w:tbl><w:p/>"#,
    );
    let saved = craft_docx::write(&d).unwrap();
    let xml = text(&unzip(&saved), "word/document.xml");
    assert!(xml.contains("<w:tblPrEx>"), "row table borders were dropped: {xml}");
    assert!(xml.contains("<w:insideV"));
    let again = craft_docx::read(&saved).unwrap();
    assert_eq!(d.body, again.body);
}

#[test]
fn field_result_keeps_run_props() {
    let styles = format!(
        r#"<w:styles {W_NS}><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:rPr><w:sz w:val="8"/></w:rPr></w:style><w:style w:type="character" w:styleId="Result"><w:name w:val="Result"/><w:rPr><w:sz w:val="16"/><w:b/></w:rPr></w:style></w:styles>"#
    );
    for result_pr in [r#"<w:sz w:val="16"/><w:b/>"#, r#"<w:rStyle w:val="Result"/>"#, ""] {
        for simple in [false, true] {
            let result = format!(r#"<w:r><w:rPr>{result_pr}</w:rPr><w:t>7</w:t></w:r>"#);
            let field = if simple {
                format!(r#"<w:fldSimple w:instr="PAGE" w:fldLock="1" w:dirty="1">{result}</w:fldSimple>"#)
            } else {
                format!(
                    r#"<w:r><w:rPr><w:sz w:val="6"/><w:i/></w:rPr><w:fldChar w:fldCharType="begin" w:fldLock="1" w:dirty="1"/></w:r><w:r><w:instrText>PAGE</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:rPr><w:sz w:val="40"/></w:rPr><w:t/></w:r>{result}<w:r><w:rPr><w:sz w:val="50"/></w:rPr><w:fldChar w:fldCharType="end"/></w:r>"#
                )
            };
            let body = format!(r#"<w:p><w:r><w:rPr><w:sz w:val="16"/></w:rPr><w:t>Counter </w:t></w:r>{field}</w:p>"#);
            let mut d = craft_docx::read(&docx(&body, &[("styles", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
            for _ in 0..2 {
                let p = paras(&d)[0];
                let props = p.props_of_char("Counter ".len());
                assert_eq!(p.props_at(0).size, Some(8.0));
                assert_eq!(props.size, result_pr.starts_with("<w:sz").then_some(8.0), "simple={simple}, result={result_pr}");
                assert_eq!(props.style.as_deref(), result_pr.starts_with("<w:rStyle").then_some("Result"));
                assert_eq!(props.italic, None);
                assert!(
                    matches!(&p.objects[0], InlineObject::Field { instr, result, locked: true, dirty: true, .. } if instr == "PAGE" && result == "7")
                );
                d = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
            }
        }
    }
}

#[test]
fn empty_field_keeps_begin_props() {
    let d = read_body(
        r#"<w:p><w:r><w:rPr><w:sz w:val="12"/><w:i/></w:rPr><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText>PAGE</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:rPr><w:sz w:val="40"/></w:rPr><w:t/></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r></w:p>"#,
    );
    let p = paras(&d)[0];
    assert_eq!(p.props_at(0).size, Some(6.0));
    assert_eq!(p.props_at(0).italic, Some(true));
    assert!(matches!(&p.objects[0], InlineObject::Field { result, .. } if result.is_empty()));
}

#[test]
fn shape_dashes_import_and_save() {
    use craft_wordmodel::line_dash::LineDash;
    for (xml, expected) in [
        (r#"<a:prstDash val="dash"/>"#, LineDash::Dash),
        (r#"<a:prstDash val="sysDashDot"/>"#, LineDash::SystemDashDot),
        (
            r#"<a:custDash><a:ds d="400000" sp="300000"/><a:ds d="100000" sp="300000"/></a:custDash>"#,
            LineDash::Custom(vec![(400_000, 300_000), (100_000, 300_000)]),
        ),
        (r#"<a:custDash><a:ds d="400%" sp="300%"/></a:custDash>"#, LineDash::Custom(vec![(400_000, 300_000)])),
        (r#"<a:custDash><a:ds d="NaN%" sp="-1"/></a:custDash>"#, LineDash::Solid),
        (r#"<a:prstDash val="solid"/>"#, LineDash::Solid),
        ("", LineDash::Solid),
    ] {
        let sppr = format!(r#"<a:prstGeom prst="rect"/><a:noFill/><a:ln w="12700"><a:solidFill><a:srgbClr val="C00000"/></a:solidFill>{xml}</a:ln>"#);
        let body = anchored_wsp("Annotation", 889000, 355600, &sppr, "", "<wps:cNvSpPr/>");
        let d = read_body(&format!("<w:p>{body}</w:p>"));
        let saved = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
        for doc in [&d, &saved] {
            let InlineObject::Shape { w, h, stroke, stroke_width, extra, .. } = &paras(doc)[0].objects[0] else { panic!("shape") };
            assert_eq!(extra.dash, expected);
            assert_eq!((*w, *h, *stroke, *stroke_width), (70.0, 28.0, Some(Rgb(192, 0, 0)), 1.0));
        }
    }
}

/// Preserve explicit caps, default missing/unknown caps, and retain caps on unpainted outlines.
#[test]
fn shape_caps_import_and_round_trip() {
    use craft_wordmodel::connector::LineCap;
    for (attr, expected) in
        [("", LineCap::Flat), ("flat", LineCap::Flat), ("sq", LineCap::Square), ("rnd", LineCap::Round), ("unknown", LineCap::Flat)]
    {
        for outline in [true, false] {
            let cap = if attr.is_empty() { String::new() } else { format!(r#" cap="{attr}""#) };
            let fill = if outline { r#"<a:solidFill><a:srgbClr val="C00000"/></a:solidFill>"# } else { "<a:noFill/>" };
            let sppr = format!(r#"<a:prstGeom prst="line"/><a:noFill/><a:ln w="12700"{cap}>{fill}</a:ln>"#);
            let body = anchored_wsp("Cap probe", 889000, 0, &sppr, "", "<wps:cNvSpPr/>");
            let d = read_body(&format!("<w:p>{body}</w:p>"));
            let saved = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
            for doc in [&d, &saved] {
                let InlineObject::Shape { extra, .. } = &paras(doc)[0].objects[0] else { panic!("shape") };
                assert_eq!(extra.cap, expected, "{attr:?}, outline={outline}");
            }
        }
    }
}

/// Preserve direct and shapetype-inherited VML end caps through a DrawingML save.
#[test]
fn vml_line_caps_import_and_round_trip() {
    use craft_wordmodel::connector::LineCap;
    for (attr, expected) in [("", LineCap::Flat), ("flat", LineCap::Flat), ("square", LineCap::Square), ("round", LineCap::Round)] {
        for inherited in [false, true] {
            let cap = if attr.is_empty() { String::new() } else { format!(r#" endcap="{attr}""#) };
            let stroke = format!("<v:stroke{cap}/>");
            let (base, own) = if inherited { (stroke.as_str(), "") } else { ("", stroke.as_str()) };
            let body = format!(
                r##"<w:p><w:r><w:pict><v:shapetype id="probe" o:spt="32">{base}</v:shapetype><v:shape type="#probe" style="width:40pt;height:1pt" strokecolor="#ff0000">{own}</v:shape></w:pict></w:r></w:p>"##
            );
            let d = read_body(&body);
            let saved = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
            for doc in [&d, &saved] {
                let InlineObject::Shape { extra, .. } = &paras(doc)[0].objects[0] else { panic!("shape") };
                assert_eq!(extra.cap, expected, "{attr:?}, inherited={inherited}");
            }
        }
    }
}

#[test]
fn bookmark_end_name_and_id_trim() {
    let body = r#"<w:p>
        <w:bookmarkStart w:id=" 42 " w:name="section_intro"/>
        <w:r><w:t>Hello</w:t></w:r>
        <w:bookmarkEnd w:id="42"/>
        <w:bookmarkEnd w:id="999" w:name="standalone_target"/>
    </w:p>"#;
    let doc = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let p = doc.body.first().unwrap().as_para().unwrap();
    let names: Vec<(&'static str, String)> = p
        .objects
        .iter()
        .filter_map(|o| match o {
            InlineObject::BookmarkStart { name } => Some(("start", name.clone())),
            InlineObject::BookmarkEnd { name } => Some(("end", name.clone())),
            _ => None,
        })
        .collect();
    assert_eq!(names, vec![("start", "section_intro".into()), ("end", "section_intro".into()), ("end", "standalone_target".into())]);
}

#[test]
fn zero_effects_stay_zero_rotated() {
    const ANGLE_UNITS_PER_DEGREE: i32 = 60_000;

    // ECMA-376 §20.4.2.6: zero effect extents add no space around a rotated picture.
    for degrees in [0, 90, 180, 270] {
        for effects in ["", r#"<wp:effectExtent l="0" t="0" r="0" b="0"/>"#] {
            let body = format!(
                r#"<w:p><w:r><w:drawing><wp:inline><wp:extent cx="914400" cy="457200"/>{effects}<wp:docPr id="1" name="Synthetic picture"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rId1"/></pic:blipFill><pic:spPr><a:xfrm rot="{}"><a:off x="0" y="0"/><a:ext cx="914400" cy="457200"/></a:xfrm></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>"#,
                degrees * ANGLE_UNITS_PER_DEGREE
            );
            let d = craft_docx::read(&docx(&body, &[("rId1", "image", "media/marker.png")], &[("word/media/marker.png", "synthetic")])).unwrap();
            let (w, h, float) = paras(&d)[0].objects[0].frame().unwrap();
            assert_eq!(float.rot, degrees as f32);
            assert_eq!(float.effect, [0.0; 4], "rotation {degrees} must not invent effects");
            let (px, py) = float.spin_pad(w, h);
            let expected = if degrees % 180 == 0 { (w, h) } else { (h, w) };
            assert!((w + 2.0 * px - expected.0).abs() < 0.001);
            assert!((h + 2.0 * py - expected.1).abs() < 0.001);
        }
    }
}

/// A turned picture whose file keeps no room for the turn (no or a zero `wp:effectExtent`) is
/// marked so its line keeps to its frame as in Word, and saves that way; one with the room keeps
/// its rotated bounds.
#[test]
fn bare_turns_are_kept_through_a_save() {
    let pic = |effects: &str| {
        format!(
            r#"<w:p><w:r><w:drawing><wp:inline><wp:extent cx="1524000" cy="762000"/>{effects}<wp:docPr id="1" name="Synthetic picture"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rId1"/></pic:blipFill><pic:spPr><a:xfrm rot="2700000"><a:off x="0" y="0"/><a:ext cx="1524000" cy="762000"/></a:xfrm></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>"#
        )
    };
    let read =
        |body: &str| craft_docx::read(&docx(body, &[("rId1", "image", "media/marker.png")], &[("word/media/marker.png", "synthetic")])).unwrap();
    let bare = |d: &Document| paras(d)[0].objects[0].frame().unwrap().2.bare_turn;
    for effects in ["", r#"<wp:effectExtent l="0" t="0" r="0" b="0"/>"#] {
        let d = read(&pic(effects));
        assert!(bare(&d), "{effects:?}");
        let out = craft_docx::write(&d).unwrap();
        let body = text(&unzip(&out), "word/document.xml");
        assert_eq!(attr_values(&body, "wp:effectExtent", "t"), ["0"]);
        assert!(bare(&craft_docx::read(&out).unwrap()));
    }
    // 120 × 60 pt at 45°: Word's rotated-bounds room, 3.64 pt wider and 33.64 pt taller each side.
    let d = read(&pic(r#"<wp:effectExtent l="46210" t="427210" r="46210" b="427210"/>"#));
    assert!(!bare(&d));
    let mut d = read(&pic(""));
    let f = first_object(&mut d).float_mut().unwrap();
    f.set_spin(craft_wordmodel::geom::Spin::new(30.0, false, false));
    assert!(!f.bare_turn, "turned here: the rotated bounds again");
    // A shadow's room added later: saved, and so laid out, with the turn's room again.
    let mut d = read(&pic(""));
    let f = first_object(&mut d).float_mut().unwrap();
    f.effect = [2.0; 4];
    assert!(!f.is_bare_turn());
    let out = craft_docx::write(&d).unwrap();
    assert_ne!(attr_values(&text(&unzip(&out), "word/document.xml"), "wp:effectExtent", "t"), ["0"]);
    // Made floating: saved with the turn's room, so it opens again as an ordinary turn.
    let mut d = read(&pic(""));
    let f = first_object(&mut d).float_mut().unwrap();
    f.wrap = craft_wordmodel::para::Wrap::Square;
    assert!(!f.is_bare_turn());
    let out = craft_docx::write(&d).unwrap();
    assert_ne!(attr_values(&text(&unzip(&out), "word/document.xml"), "wp:effectExtent", "t"), ["0"]);
    assert!(!bare(&craft_docx::read(&out).unwrap()));
    // Only inline ones: a floating one keeps text clear of its rotated bounds as before.
    let anchored = pic("").replace("<wp:inline>", "<wp:anchor>").replace("</wp:inline>", "</wp:anchor>");
    assert!(!bare(&read(&anchored)));
}

/// The math namespace, declared on the math element itself (the fixture root doesn't).
const M_NS: &str = r#"xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math""#;

fn equations(p: &Paragraph) -> Vec<(String, bool)> {
    p.objects
        .iter()
        .filter_map(|o| match o {
            InlineObject::Equation { linear, display, .. } => Some((linear.clone(), *display)),
            _ => None,
        })
        .collect()
}

/// #1273: an equation straight in the body (EG_BlockLevelElts allows math content) gets a
/// paragraph of its own instead of vanishing.
#[test]
fn body_level_equation_is_kept() {
    let d = read_body(&format!(
        r#"<w:p><w:r><w:t>before</w:t></w:r></w:p><m:oMathPara {M_NS}><m:oMath><m:r><m:t>a=b</m:t></m:r></m:oMath></m:oMathPara><m:oMath {M_NS}><m:r><m:t>c</m:t></m:r></m:oMath><w:p><w:r><w:t>after</w:t></w:r></w:p>"#
    ));
    let ps = paras(&d);
    assert_eq!(ps.len(), 4, "{:?}", ps.iter().map(|p| p.plain_text()).collect::<Vec<_>>());
    assert_eq!(equations(ps[1]), vec![("a=b".to_string(), true)]);
    assert_eq!(equations(ps[2]), vec![("c".to_string(), false)]);
}

/// #1273: an equation guarded by markup compatibility (`Requires="m"`) is read as an equation,
/// not replaced by its fallback.
#[test]
fn equation_in_alternate_content_is_read() {
    let d = read_body(&format!(
        r#"<w:p><mc:AlternateContent {M_NS}><mc:Choice Requires="m"><m:oMath><m:r><m:t>x+1</m:t></m:r></m:oMath></mc:Choice><mc:Fallback><w:r><w:t>[picture]</w:t></w:r></mc:Fallback></mc:AlternateContent></w:p>"#
    ));
    let p = paras(&d)[0];
    assert_eq!(equations(p), vec![("x+1".to_string(), false)]);
    assert!(!p.plain_text().contains("[picture]"));
}

/// A fill's `a:alpha` is its opacity: a translucent white wash over a picture stayed opaque and
/// hid the picture.
#[test]
fn a_shape_fill_keeps_its_transparency() {
    let fill =
        r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:solidFill><a:srgbClr val="FFFFFF"><a:alpha val="30980"/></a:srgbClr></a:solidFill>"#;
    let d = read_body(&format!("<w:p>{}</w:p>", anchored_wsp("Wash", 1270000, 635000, fill, "", "<wps:cNvSpPr/>")));
    let transparency = |d: &Document| match &paras(d)[0].objects[0] {
        InlineObject::Shape { fill: Some(craft_wordmodel::fill::Fill::Solid { color, transparency }), .. } => (Some(*color), *transparency),
        o => panic!("{o:?}"),
    };
    const FILL_ALPHA: u32 = 30_980;
    const ALPHA_SCALE: f32 = 100_000.0;
    // Canonical Fill stores the percentage computed from opacity, including f32 rounding.
    let expected = 100.0 - (FILL_ALPHA as f32 / ALPHA_SCALE) * 100.0;
    assert_eq!(transparency(&d), (Some(Rgb(255, 255, 255)), expected));
    let bytes = craft_docx::write(&d).unwrap();
    let parts = unzip(&bytes);
    let xml = String::from_utf8_lossy(parts.get("word/document.xml").unwrap());
    assert!(xml.contains(&format!("<a:alpha val=\"{FILL_ALPHA}\"/>")), "{xml}");
    let again = craft_docx::read(&bytes).unwrap();
    assert_eq!(transparency(&again), (Some(Rgb(255, 255, 255)), expected));
}

/// #1500: gradient fills and transparency on shapes (the cases in the issue), from the shape's
/// own properties, the theme's fill styles (`a:fillRef` 3 and 1003, as Word's cover pages use),
/// a group's fill (`a:grpFill`), an outline gradient and VML's `v:fill`. Each is read as the
/// file states it and survives saving.
#[test]
fn shape_gradients_and_transparency_are_read_and_survive_saving() {
    use craft_wordmodel::fill::{Gradient, GradientFlip, GradientKind, PathShape};
    use craft_wordmodel::wordart::GradStop;
    use std::sync::Arc;
    let theme = r#"<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="T"><a:themeElements><a:fmtScheme name="T"><a:fillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:schemeClr val="phClr"/></a:gs><a:gs pos="100000"><a:schemeClr val="phClr"><a:shade val="50000"/></a:schemeClr></a:gs></a:gsLst><a:lin ang="5400000" scaled="0"/></a:gradFill></a:fillStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:schemeClr val="phClr"/></a:gs><a:gs pos="100000"><a:srgbClr val="000000"/></a:gs></a:gsLst><a:path path="circle"><a:fillToRect l="50000" t="50000" r="50000" b="50000"/></a:path></a:gradFill></a:bgFillStyleLst></a:fmtScheme></a:themeElements></a:theme>"#;
    let rect = r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>"#;
    let wsp = |sppr: &str, style: &str| anchored_wsp("S", 914400, 914400, &format!("{rect}{sppr}"), style, "<wps:cNvSpPr/>");
    let fill_ref = |idx: u32| {
        format!(
            r#"<wps:style><a:lnRef idx="0"><a:srgbClr val="4080C0"/></a:lnRef><a:fillRef idx="{idx}"><a:srgbClr val="4080C0"/></a:fillRef><a:effectRef idx="0"><a:srgbClr val="4080C0"/></a:effectRef><a:fontRef idx="minor"/></wps:style>"#
        )
    };
    let gs = |pos: u32, c: &str| format!(r#"<a:gs pos="{pos}"><a:srgbClr val="{c}"/></a:gs>"#);
    let shapes = [
        // A: 30%-opaque white.
        wsp(r#"<a:solidFill><a:srgbClr val="FFFFFF"><a:alpha val="30000"/></a:srgbClr></a:solidFill>"#, ""),
        // B: two stops top to bottom, the second 40% opaque.
        wsp(&format!(r#"<a:gradFill rotWithShape="1"><a:gsLst>{}<a:gs pos="100000"><a:srgbClr val="0000FF"><a:alpha val="40000"/></a:srgbClr></a:gs></a:gsLst><a:lin ang="5400000" scaled="1"/></a:gradFill>"#, gs(0, "FF0000")), ""),
        // C: three stops at 45°.
        wsp(&format!(r#"<a:gradFill><a:gsLst>{}{}{}</a:gsLst><a:lin ang="2700000" scaled="0"/></a:gradFill>"#, gs(0, "FF0000"), gs(50000, "00FF00"), gs(100000, "0000FF")), ""),
        // D: circular from the centre.
        wsp(&format!(r#"<a:gradFill rotWithShape="1"><a:gsLst>{}{}</a:gsLst><a:path path="circle"><a:fillToRect l="50000" t="50000" r="50000" b="50000"/></a:path></a:gradFill>"#, gs(0, "FFFFFF"), gs(100000, "000000")), ""),
        // E: rectangular from a corner, flipped and tiled, not turning with the shape.
        wsp(&format!(r#"<a:gradFill flip="xy" rotWithShape="0"><a:gsLst>{}{}</a:gsLst><a:path path="rect"><a:fillToRect l="100000" t="100000" r="0" b="0"/></a:path><a:tileRect l="-100000" t="-100000" r="0" b="0"/></a:gradFill>"#, gs(0, "FFFFFF"), gs(100000, "000000")), ""),
        // F, G: the theme's fill style 3 and background style 3 in the reference's colour.
        wsp("", &fill_ref(3)),
        wsp("", &fill_ref(1003)),
        // H: an outline gradient.
        wsp(&format!(r#"<a:noFill/><a:ln w="12700"><a:gradFill><a:gsLst>{}{}{}</a:gsLst><a:lin ang="0" scaled="0"/></a:gradFill></a:ln>"#, gs(0, "FF0000"), gs(50000, "00FF00"), gs(100000, "0000FF")), ""),
    ]
    .concat();
    let member = |id: u32, paint: &str| {
        format!(
            r#"<wps:wsp><wps:cNvPr id="{id}" name="M{id}"/><wps:cNvSpPr/><wps:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/></a:xfrm>{rect}{paint}</wps:spPr><wps:bodyPr/></wps:wsp>"#
        )
    };
    // I: a group with a gradient fill; one member takes it (`a:grpFill`), one has its own, and
    // one in a nested group without a fill of its own takes the outer group's.
    let group = format!(
        r#"<w:r><w:drawing><wp:inline><wp:extent cx="914400" cy="914400"/><wp:docPr id="9" name="G"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup"><wpg:wgp><wpg:cNvGrpSpPr/><wpg:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/><a:chOff x="0" y="0"/><a:chExt cx="914400" cy="914400"/></a:xfrm><a:gradFill><a:gsLst>{}{}</a:gsLst><a:lin ang="0" scaled="0"/></a:gradFill></wpg:grpSpPr>{}{}<wpg:grpSp><wpg:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/><a:chOff x="0" y="0"/><a:chExt cx="914400" cy="914400"/></a:xfrm></wpg:grpSpPr>{}</wpg:grpSp></wpg:wgp></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#,
        gs(0, "112233"),
        gs(100000, "445566"),
        member(10, "<a:grpFill/>"),
        member(11, r#"<a:solidFill><a:srgbClr val="00FF00"/></a:solidFill>"#),
        member(12, "<a:grpFill/>")
    );
    // VML: a linear gradient to `color2`, half opaque.
    let vml = r##"<w:r><w:pict><v:rect style="width:72pt;height:72pt" fillcolor="#ff0000" stroked="f"><v:fill type="gradient" color2="#0000ff" opacity="0.5"/></v:rect></w:pict></w:r>"##;
    let bytes = docx(&format!("<w:p>{shapes}{group}{vml}</w:p>"), &[("rId2", "theme", "theme/theme1.xml")], &[("word/theme/theme1.xml", theme)]);

    let stop = |pos: f32, c: Rgb, transparency: f32| GradStop { pos, color: c, transparency };
    let (red, green, blue, white, black) = (Rgb(255, 0, 0), Rgb(0, 255, 0), Rgb(0, 0, 255), Rgb::WHITE, Rgb::BLACK);
    let grad = |stops: Vec<GradStop>, kind: GradientKind, rot: bool| {
        Fill::Gradient(Arc::new(Gradient { stops, kind, tile: None, rot_with_shape: rot, flip: GradientFlip::None }))
    };
    let lin = |angle: f32, scaled: bool| GradientKind::Linear { angle, scaled };
    let centre = GradientKind::Path { shape: PathShape::Circle, focus: [50.0; 4] };
    let ph = Rgb(0x40, 0x80, 0xC0);
    let expected = [
        Some(Fill::Solid { color: white, transparency: 70.0 }),
        Some(grad(vec![stop(0.0, red, 0.0), stop(100.0, blue, 60.0)], lin(90.0, true), true)),
        Some(grad(vec![stop(0.0, red, 0.0), stop(50.0, green, 0.0), stop(100.0, blue, 0.0)], lin(45.0, false), false)),
        Some(grad(vec![stop(0.0, white, 0.0), stop(100.0, black, 0.0)], centre, true)),
        Some(Fill::Gradient(Arc::new(Gradient {
            stops: vec![stop(0.0, white, 0.0), stop(100.0, black, 0.0)],
            kind: GradientKind::Path { shape: PathShape::Rect, focus: [100.0, 100.0, 0.0, 0.0] },
            tile: Some([-100.0, -100.0, 0.0, 0.0]),
            rot_with_shape: false,
            flip: GradientFlip::Xy,
        }))),
        Some(grad(vec![stop(0.0, ph, 0.0), stop(100.0, Rgb(0x20, 0x40, 0x60), 0.0)], lin(90.0, false), true)),
        Some(grad(vec![stop(0.0, ph, 0.0), stop(100.0, black, 0.0)], centre, true)),
        None,
    ];
    let check = |d: &Document| {
        let objs = &paras(d)[0].objects;
        assert_eq!(objs.len(), expected.len() + 2);
        for (i, want) in expected.iter().enumerate() {
            let InlineObject::Shape { fill, .. } = &objs[i] else { panic!("{:?}", objs[i]) };
            assert_eq!(fill, want, "shape {i}");
        }
        let InlineObject::Shape { stroke, extra, .. } = &objs[7] else { panic!() };
        let outline = grad(vec![stop(0.0, red, 0.0), stop(50.0, green, 0.0), stop(100.0, blue, 0.0)], lin(0.0, false), false);
        assert_eq!((*stroke, extra.outline_fill.as_ref()), (Some(green), Some(&outline)), "outline drawn in its middle stop");
        let InlineObject::Group { children, .. } = &objs[8] else { panic!("{:?}", objs[8]) };
        let fills: Vec<_> = children.iter().map(|c| if let InlineObject::Shape { fill, .. } = &c.obj { fill.clone() } else { None }).collect();
        let group_fill = grad(vec![stop(0.0, Rgb(0x11, 0x22, 0x33), 0.0), stop(100.0, Rgb(0x44, 0x55, 0x66), 0.0)], lin(0.0, false), false);
        assert_eq!(fills, [Some(group_fill.clone()), Some(Fill::solid(green)), Some(group_fill)], "a:grpFill takes the group's fill");
        let InlineObject::Shape { fill, .. } = &objs[9] else { panic!("{:?}", objs[9]) };
        assert_eq!(fill.as_ref(), Some(&grad(vec![stop(0.0, red, 50.0), stop(100.0, blue, 0.0)], lin(90.0, false), true)), "VML gradient");
    };
    let d = craft_docx::read(&bytes).unwrap();
    check(&d);
    check(&craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap());
}

/// #3415: a table style's row and column band sizes (`w:tblStyleRowBandSize`,
/// `w:tblStyleColBandSize`, ECMA-376 §17.7.6.5 and §17.7.6.7) are read, zero included, and left
/// unset when the file has none, which is how Word reads it: no bands. A style based on one with
/// sizes inherits them.
#[test]
fn table_style_band_sizes_read_as_word_reads_them() {
    let band = r#"<w:tblStylePr w:type="band1Horz"><w:tcPr><w:shd w:val="clear" w:color="auto" w:fill="C1E4F5"/></w:tcPr></w:tblStylePr>"#;
    let styles = format!(
        r#"<w:styles {W_NS}>
 <w:style w:type="table" w:default="1" w:styleId="TableNormal"><w:name w:val="Normal Table"/></w:style>
 <w:style w:type="table" w:styleId="Missing"><w:name w:val="Missing"/><w:basedOn w:val="TableNormal"/>{band}</w:style>
 <w:style w:type="table" w:styleId="One"><w:name w:val="One"/><w:basedOn w:val="TableNormal"/><w:tblPr><w:tblStyleRowBandSize w:val="1"/><w:tblStyleColBandSize w:val="1"/></w:tblPr>{band}</w:style>
 <w:style w:type="table" w:styleId="Zero"><w:name w:val="Zero"/><w:basedOn w:val="One"/><w:tblPr><w:tblStyleRowBandSize w:val="0"/></w:tblPr></w:style>
 <w:style w:type="table" w:styleId="Child"><w:name w:val="Child"/><w:basedOn w:val="One"/>{band}</w:style>
</w:styles>"#
    );
    let d = craft_docx::read(&docx("<w:p/>", &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
    let sizes = |id: &str| d.styles.table_style(id).map(|t| (t.parts.band_size, t.parts.col_band_size));
    assert_eq!(sizes("Missing"), Some((None, None)), "no sizes: no bands, as in Word");
    assert_eq!(sizes("One"), Some((Some(1), Some(1))));
    assert_eq!(sizes("Zero"), Some((Some(0), Some(1))));
    assert_eq!(sizes("Child"), Some((Some(1), Some(1))), "inherited");
    // Written back as read: still no sizes where there were none.
    let xml = text(&unzip(&craft_docx::write(&d).unwrap()), "word/styles.xml");
    let style = |id: &str| {
        let start = xml.find(&format!(r#"w:styleId="{id}""#)).unwrap();
        xml[start..start + xml[start..].find("</w:style>").unwrap()].to_string()
    };
    assert!(!style("Missing").contains("BandSize"), "{}", style("Missing"));
    assert!(style("One").contains(r#"<w:tblStyleRowBandSize w:val="1"/><w:tblStyleColBandSize w:val="1"/>"#), "{}", style("One"));
    assert!(style("Zero").contains(r#"<w:tblStyleRowBandSize w:val="0"/>"#), "{}", style("Zero"));
}

/// #3415: a document saved with one of our banded table styles tells Word its band sizes, so Word
/// shades the same rows we do (it reads a style without them as having no bands).
#[test]
fn our_banded_table_styles_write_their_band_sizes() {
    let d = Document::new();
    let xml = text(&unzip(&craft_docx::write(&d).unwrap()), "word/styles.xml");
    let start = xml.find(r#"w:styleId="GridTable4AccentBlue""#).expect("Grid Table 4 – Blue is written");
    let style = &xml[start..start + xml[start..].find("</w:style>").unwrap()];
    assert!(style.contains(r#"<w:tblPr><w:tblStyleRowBandSize w:val="1"/><w:tblStyleColBandSize w:val="1"/>"#), "{style}");
    let back = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(back.styles.table_style("GridTable4AccentBlue").map(|t| t.parts.band_size), Some(Some(1)));
}

#[test]
fn vml_shape_wrap_side_and_anchor_case_insensitivity() {
    let body = r##"<w:p>
        <w:r>
            <w:pict xmlns:w10="urn:schemas-microsoft-com:office:word">
                <v:rect style="position:absolute;width:100pt;height:50pt;mso-position-horizontal-relative:Page;mso-position-vertical-relative:Margin" filled="False" stroked="t">
                    <w10:wrap type="Square" side="left"/>
                </v:rect>
            </w:pict>
        </w:r>
    </w:p>"##;
    let doc = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let p = doc.body.iter().find_map(|b| b.as_para()).unwrap();
    let shape = match p.objects.first() {
        Some(InlineObject::Shape { fill, float, .. }) => (fill, float),
        o => panic!("expected shape, got {o:?}"),
    };
    assert_eq!(*shape.0, None);
    assert_eq!(shape.1.wrap, craft_wordmodel::para::Wrap::Square);
    assert_eq!(shape.1.wrap_text, craft_wordmodel::para::WrapText::Left);
    assert_eq!(shape.1.h_rel, craft_wordmodel::para::Anchor::Page);
    assert_eq!(shape.1.v_rel, craft_wordmodel::para::Anchor::Margin);
}

#[test]
fn vml_textbox_style_anchor_and_fit() {
    let body = r#"<w:p>
        <w:r>
            <w:pict>
                <v:rect style="width:100pt;height:50pt">
                    <v:textbox style="v-text-anchor:Middle;mso-fit-shape-to-text:True">
                        <w:txbxContent>
                            <w:p><w:r><w:t>Centered text</w:t></w:r></w:p>
                        </w:txbxContent>
                    </v:textbox>
                </v:rect>
            </w:pict>
        </w:r>
    </w:p>"#;
    let doc = craft_docx::read(&docx(body, &[], &[])).unwrap();
    let p = doc.body.first().unwrap().as_para().unwrap();
    let story_id = match p.objects.first() {
        Some(InlineObject::Shape { story: Some(id), .. }) => *id,
        o => panic!("expected shape with story, got {o:?}"),
    };
    let tb = doc.parts.get(&story_id).unwrap();
    assert_eq!(tb.body.anchor, craft_wordmodel::props::VAlign::Center);
    assert!(tb.body.auto_fit);
}

/// #2601: a drop-cap frame of two letters in two fonts. The first letter's font is the cap's; only
/// the runs in that font get the text's font back, the other letter keeps its own.
#[test]
fn drop_cap_frame_keeps_other_fonts() {
    let body = r#"<w:p><w:pPr><w:framePr w:dropCap="drop" w:lines="3" w:wrap="around" w:vAnchor="text" w:hAnchor="text"/></w:pPr><w:r><w:rPr><w:rFonts w:ascii="Liberation Mono" w:hAnsi="Liberation Mono"/></w:rPr><w:t>A</w:t></w:r><w:r><w:rPr><w:rFonts w:ascii="Liberation Sans" w:hAnsi="Liberation Sans"/></w:rPr><w:t>b</w:t></w:r></w:p>
        <w:p><w:r><w:rPr><w:rFonts w:ascii="Liberation Serif" w:hAnsi="Liberation Serif"/></w:rPr><w:t>c tale</w:t></w:r></w:p>"#;
    let d = read_body(body);
    let p = paras(&d);
    assert_eq!(p.len(), 1, "the frame merges into its paragraph");
    assert_eq!(p[0].props.drop_cap_font.as_deref(), Some("Liberation Mono"));
    assert_eq!(p[0].props_of_char(0).font.as_deref(), Some("Liberation Serif"), "the cap letter gets the text's font");
    assert_eq!(p[0].props_of_char(1).font.as_deref(), Some("Liberation Sans"), "the other letter keeps its own");
}

/// A VML horizontal rule (`o:hr`, a web page's `<hr>` pasted into Word) is read as one: the whole
/// line when it has no width and no `o:hrpct`, a share of it (`o:hrpct`, tenths of a percent), or
/// its own width (`o:hrpct="0"`), placed by `o:hralign`. It saves back as the same VML rule.
#[test]
fn vml_horizontal_rules_are_read_and_kept() {
    use craft_wordmodel::connector::HorizontalRule;
    use craft_wordmodel::props::Align;
    let hr = |attrs: &str, style: &str| format!(r#"<w:p><w:r><w:pict><v:rect style="{style}" {attrs}/></w:pict></w:r></w:p>"#);
    let body = [
        hr(r#"o:hralign="center" o:hrstd="t" o:hr="t""#, "width:0;height:1.5pt"),
        hr(r#"o:hrpct="500" o:hralign="right" o:hr="t""#, "width:0;height:1.5pt"),
        hr(r#"o:hrpct="0" o:hralign="center" o:hr="t""#, "width:100pt;height:3pt"),
        hr("", "width:100pt;height:3pt"),
    ]
    .concat();
    let rules = |d: &Document| -> Vec<(Option<HorizontalRule>, f32)> {
        paras(d)
            .iter()
            .filter_map(|p| p.objects.iter().find_map(|o| if let InlineObject::Shape { extra, w, .. } = o { Some((extra.hr, *w)) } else { None }))
            .collect()
    };
    let d = read_body(&body);
    let got = rules(&d);
    assert_eq!(
        got,
        [
            (Some(HorizontalRule { pct: 100.0, align: Align::Center, standard: true }), 0.0),
            (Some(HorizontalRule { pct: 50.0, align: Align::Right, standard: false }), 0.0),
            (Some(HorizontalRule { pct: 0.0, align: Align::Center, standard: false }), 100.0),
            (None, 100.0),
        ]
    );
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(rules(&again)[..3], got[..3]);
    // A rule's rotation and flips are kept.
    let spin = |d: &Document| paras(d)[0].objects.iter().find_map(|o| o.frame()).map(|(_, _, f)| f.spin());
    let d = read_body(&hr(r#"o:hrpct="500" o:hr="t""#, "width:0;height:1.5pt;rotation:45;flip:x y"));
    assert_eq!(spin(&d), Some(craft_wordmodel::geom::Spin::new(45.0, true, true)));
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(spin(&again), spin(&d));
    // A see-through rule stays see-through.
    let fill = |d: &Document| paras(d)[0].objects.iter().find_map(|o| if let InlineObject::Shape { fill, .. } = o { fill.clone() } else { None });
    let d = read_body(
        r##"<w:p><w:r><w:pict><v:rect style="width:0;height:1.5pt" o:hr="t" fillcolor="#ff0000"><v:fill opacity="0.25"/></v:rect></w:pict></w:r></w:p>"##,
    );
    let Some(craft_wordmodel::fill::Fill::Solid { transparency, .. }) = fill(&d) else { panic!("{:?}", fill(&d)) };
    assert!((transparency - 75.0).abs() < 0.01, "{transparency}");
    let again = craft_docx::read(&craft_docx::write(&d).unwrap()).unwrap();
    assert_eq!(fill(&again), fill(&d));
    // A positioned or hidden rule stays a plain shape, keeping its placement and visibility.
    let body = [
        hr(r#"o:hralign="center" o:hr="t""#, "position:absolute;margin-left:10pt;margin-top:20pt;width:100pt;height:2pt"),
        hr(r#"o:hralign="center" o:hr="t""#, "visibility:hidden;width:0;height:2pt"),
    ]
    .concat();
    let d = read_body(&body);
    assert_eq!(rules(&d).iter().map(|r| r.0).collect::<Vec<_>>(), [None, None]);
}