6ef13b2cc8a6
roundtrip.rs
//! Round-trip tests: build documents programmatically → write → read → compare.
use std::sync::Arc;
use wordcraft_doc::fill::Fill;
use wordcraft_doc::numbering::ListKind;
use wordcraft_doc::para::{Anchor, Float, FloatAlign, NoteKind, ShapeKind, Wrap};
use wordcraft_doc::props::{
Align, Border, BorderStyle, Borders, CharProps, HeightRule, Highlight, LineSpacing, NumRef, ParaProps, ParagraphTextDirection, PropChange, Rgb,
RowProps, TabAlign, TabLeader, TabStop, TableLook, TextAlignment, TextColor, TextDirection, Underline, VAlign, VMerge, VertAlign,
};
use wordcraft_doc::section::{Columns, DocGrid, DocGridType, LineNumberRestart, LineNumbering, NumFormat, PageVAlign, SectionProps, SectionStart};
use wordcraft_doc::styles::{Style, StyleKind};
use wordcraft_doc::table::{Cell, Table};
use wordcraft_doc::{Block, Blocks, Comment, Document, InlineObject, Paragraph, PartKind, Revision, RevisionKind, Source, Watermark, para_block};
fn rt(doc: &Document) -> Document {
let bytes = wordcraft_docx::write(doc).expect("write");
wordcraft_docx::read(&bytes).expect("read")
}
fn paras(doc: &Document) -> Vec<&Paragraph> {
doc.body.iter().filter_map(|b| b.as_para()).collect()
}
/// `doc` with the stacking order of its body's floating objects cleared: saving gives objects
/// without one an order (`relativeHeight`), so tests about other properties compare without it.
fn unstacked(mut doc: Document) -> Document {
for b in &mut doc.body {
if let Block::Para(p) = std::sync::Arc::make_mut(b) {
for o in &mut p.objects {
if let Some(f) = o.float_mut() {
f.z = 0;
}
}
}
}
doc
}
fn part_text(doc: &Document, id: Option<u32>) -> String {
id.and_then(|i| doc.parts.get(&i))
.map(|p| p.blocks.iter().filter_map(|b| b.as_para()).map(|p| p.plain_text()).collect::<Vec<_>>().join("\n"))
.unwrap_or_default()
}
fn doc_with(blocks: Vec<Paragraph>) -> Document {
let mut d = Document::new();
d.body = blocks.into_iter().map(para_block).collect();
d
}
/// A paragraph built from (text, props) runs.
fn para_runs(runs: &[(&str, CharProps)]) -> Paragraph {
let mut p = Paragraph::new();
for (t, c) in runs {
let off = p.len();
p.insert_text(off, t, c).unwrap();
}
p
}
fn tiny_png() -> Vec<u8> {
let img = image::RgbaImage::from_fn(3, 2, |x, y| image::Rgba([x as u8 * 80, y as u8 * 120, 200, 255]));
let mut out = std::io::Cursor::new(Vec::new());
std::io::Write::write_all(
&mut out,
&wordcraft_geom::picture::encode_format(&image::DynamicImage::from(img.clone()), image::ImageFormat::Png).unwrap(),
)
.unwrap();
out.into_inner()
}
#[test]
fn every_char_prop_round_trips() {
let all = CharProps {
style: Some("Strong".into()),
font: Some("Georgia".into()),
// The symbol's own font: the run is written as `w:sym` characters (#2036).
sym_font: Some("Wingdings".into()),
size: Some(10.5),
bold: Some(true),
italic: Some(false),
underline: Some(Underline::DotDash),
underline_color: Some(Rgb(1, 2, 3)),
strike: Some(true),
double_strike: Some(false),
color: Some(TextColor::Rgb(Rgb(0xAA, 0x10, 0x20))),
highlight: Some(Highlight::Turquoise),
shading: Some(Rgb(0xEE, 0xEE, 0x00)),
border: Some(Border { style: BorderStyle::Double, width: 1.5, color: Some(Rgb(0xC0, 0, 0)), space: 2.0 }),
vert_align: Some(VertAlign::Superscript),
caps: Some(true),
small_caps: Some(false),
hidden: Some(true),
web_hidden: Some(true),
snap_to_grid: Some(false),
spacing: Some(1.5),
scale: Some(150.0),
position: Some(3.0),
kern: Some(8.0),
emphasis: Some(wordcraft_doc::props::EmphasisMark::Comma),
ligatures: Some(wordcraft_doc::props::Ligatures { standard: true, historical: true, ..Default::default() }),
outline: Some(true),
shadow: Some(true),
emboss: Some(false),
engrave: Some(true),
// WordArt effects ([MS-DOCX] w14 run properties).
text_effects: Some(Box::new(wordcraft_doc::wordart::TextEffects {
fill: Some(wordcraft_doc::wordart::TextFill::Gradient {
stops: vec![
wordcraft_doc::wordart::GradStop { pos: 0.0, color: Rgb(0x15, 0x60, 0x82), transparency: 0.0 },
wordcraft_doc::wordart::GradStop { pos: 100.0, color: Rgb(0xE9, 0x71, 0x32), transparency: 25.0 },
],
angle: 90.0,
}),
outline: Some(wordcraft_doc::wordart::TextOutline { color: Some(Rgb(0x0E, 0x28, 0x41)), width: 1.5, transparency: 0.0 }),
shadow: Some(wordcraft_doc::effects::Shadow {
color: Rgb::BLACK,
transparency: 60.0,
blur: 4.0,
distance: 3.0,
angle: 45.0,
rot_with_shape: false,
}),
glow: Some(wordcraft_doc::effects::Glow { color: Rgb(0x0F, 0x9E, 0xD5), size: 5.0, transparency: 40.0 }),
reflection: Some(wordcraft_doc::wordart::Reflection::default()),
})),
lang: Some("fr-FR".into()),
no_proof: Some(true),
rtl: Some(false),
cs: Some(true),
font_cs: Some("B Nazanin".into()),
font_ea: Some("宋体".into()),
size_cs: Some(13.0),
bold_cs: Some(false),
italic_cs: Some(true),
lang_bidi: Some("fa-IR".into()),
lang_ea: Some("ja-JP".into()),
east_asian_layout: Some(wordcraft_doc::props::EastAsianLayout {
id: Some(3),
combine: Some(true),
combine_brackets: Some(wordcraft_doc::props::CombineBrackets::Square),
vert: Some(false),
vert_compress: Some(true),
}),
link: None,
ins: None,
del: None,
fmt_change: None,
};
let auto =
CharProps { color: Some(TextColor::Auto), highlight: Some(Highlight::None), vert_align: Some(VertAlign::Subscript), ..Default::default() };
let d = doc_with(vec![para_runs(&[("plain ", CharProps::default()), ("everything", all.clone()), (" auto", auto.clone())])]);
let r = rt(&d);
let p = paras(&r)[0];
assert_eq!(p.text, "plain everything auto");
assert_eq!(p.runs.len(), 3);
assert_eq!(p.runs[1].props, all);
assert_eq!(p.runs[2].props, auto);
assert_eq!(p.runs[0].props, CharProps::default());
}
#[test]
fn every_para_prop_round_trips() {
let b = Border { style: BorderStyle::Double, width: 0.75, color: Some(Rgb(9, 8, 7)), space: 4.0 };
let pp = ParaProps {
style: Some("Heading1".into()),
align: Some(Align::Justify),
indent_left: Some(36.0),
indent_right: Some(18.0),
indent_first: Some(-18.0),
indent_left_chars: Some(1.5),
indent_right_chars: Some(0.0),
indent_first_chars: Some(-1.0),
space_before: Some(6.0),
space_after: Some(12.0),
space_before_auto: Some(true),
space_after_auto: Some(false),
line_spacing: Some(LineSpacing::Multiple(1.5)),
contextual_spacing: Some(true),
mirror_indents: Some(true),
adjust_right_indent: Some(false),
keep_next: Some(true),
keep_lines: Some(false),
page_break_before: Some(true),
widow_control: Some(false),
outline_level: Some(2),
numbering: Some(NumRef { num: 0, level: 0 }),
tabs: Some(vec![
TabStop { pos: 72.0, align: TabAlign::Center, leader: TabLeader::Dot },
TabStop { pos: 144.0, align: TabAlign::Right, leader: TabLeader::None },
TabStop { pos: 200.0, align: TabAlign::Decimal, leader: TabLeader::Underscore },
TabStop { pos: 216.0, align: TabAlign::Clear, leader: TabLeader::None },
TabStop { pos: 250.0, align: TabAlign::Bar, leader: TabLeader::MiddleDot },
]),
shading: Some(Rgb(0xDD, 0xEE, 0xFF)),
borders: Some(Borders { top: Some(b), left: Some(Border::single(0.5)), bottom: Some(b), right: None, between: Some(b), inside_v: None }),
suppress_hyphens: Some(true),
suppress_line_numbers: Some(true),
bidi: Some(false),
text_direction: Some(ParagraphTextDirection::TbRl),
drop_cap: None,
drop_cap_margin: None,
drop_cap_distance: None,
drop_cap_font: None,
frame: Some(wordcraft_doc::props::TextFrame {
w: Some(144.0),
h: Some(36.0),
h_exact: true,
x: 0.0,
y: 12.0,
x_align: Some("right".into()),
y_align: None,
h_anchor: "margin".into(),
v_anchor: "text".into(),
wrap: "around".into(),
anchor_lock: Some(true),
h_space: 9.0,
v_space: 0.0,
}),
kinsoku: Some(false),
word_wrap: Some(false),
overflow_punct: Some(false),
top_line_punct: Some(true),
auto_space_de: Some(false),
auto_space_dn: Some(true),
num_change: None,
fmt_change: None,
snap_to_grid: Some(false),
text_alignment: Some(TextAlignment::Top),
};
let variants = [
ParaProps { line_spacing: Some(LineSpacing::AtLeast(14.0)), indent_first: Some(24.0), align: Some(Align::Center), ..Default::default() },
ParaProps { line_spacing: Some(LineSpacing::Exactly(20.0)), align: Some(Align::Right), ..Default::default() },
ParaProps { align: Some(Align::Distribute), ..Default::default() },
ParaProps { kinsoku: Some(true), word_wrap: Some(true), auto_space_dn: Some(false), ..Default::default() },
ParaProps::default(),
];
let mut ps = vec![Paragraph::with_text("main", CharProps::default())];
ps[0].props = pp.clone();
ps[0].mark = CharProps { bold: Some(true), size: Some(14.0), ..Default::default() };
for v in &variants {
let mut p = Paragraph::with_text("v", CharProps::default());
p.props = v.clone();
ps.push(p);
}
let r = rt(&doc_with(ps));
let got = paras(&r);
assert_eq!(got[0].props, pp);
assert_eq!(got[0].mark, CharProps { bold: Some(true), size: Some(14.0), ..Default::default() });
for (i, v) in variants.iter().enumerate() {
assert_eq!(&got[i + 1].props, v, "variant {i}");
}
}
#[test]
fn styles_and_lists_round_trip() {
let mut d = Document::new();
Arc::make_mut(&mut d.styles).upsert(Style {
id: "MyStyle".into(),
name: "My Style".into(),
kind: StyleKind::Paragraph,
based_on: Some("Normal".into()),
next: Some("Normal".into()),
linked: Some("MyStyleChar".into()),
para: ParaProps { space_after: Some(3.0), align: Some(Align::Center), ..Default::default() },
chr: CharProps { italic: Some(true), color: Some(TextColor::Rgb(Rgb(1, 2, 3))), ..Default::default() },
priority: Some(5),
quick: true,
hidden: false,
builtin: false,
locked: true,
default: false,
table: None,
para_change: None,
chr_change: None,
});
Arc::make_mut(&mut d.styles).upsert(Style {
id: "MyStyleChar".into(),
name: "My Style Char".into(),
kind: StyleKind::Character,
linked: Some("MyStyle".into()),
chr: CharProps { italic: Some(true), ..Default::default() },
hidden: true,
..Default::default()
});
let bullets = Arc::make_mut(&mut d.numbering).add_list(ListKind::Bullet);
let nums = Arc::make_mut(&mut d.numbering).add_list(ListKind::Legal);
let outline = Arc::make_mut(&mut d.numbering).add_list(ListKind::Outline);
if let Some(n) = Arc::make_mut(&mut d.numbering).nums.iter_mut().find(|n| n.id == outline) {
n.start_overrides.push((0, 4));
}
let mut ps = Vec::new();
for (i, num) in [bullets, nums, nums, outline].iter().enumerate() {
let mut p = Paragraph::with_text(&format!("item {i}"), CharProps::default());
p.props.numbering = Some(NumRef { num: *num, level: (i % 2) as u8 });
p.props.style = Some("MyStyle".into());
ps.push(p);
}
d.body = ps.into_iter().map(para_block).collect();
let r = rt(&d);
assert_eq!(r.numbering, d.numbering);
assert_eq!(r.styles.default_chr, d.styles.default_chr);
assert_eq!(r.styles.default_para, d.styles.default_para);
for s in &d.styles.styles {
assert_eq!(r.styles.get(&s.id), Some(s), "style {}", s.id);
}
assert_eq!(r.styles.styles.len(), d.styles.styles.len());
assert_eq!(paras(&r)[1].props.numbering, Some(NumRef { num: nums, level: 1 }));
}
/// A tracked change of a style's paragraph/run properties (#2697): valid `w:pPrChange` and
/// `w:rPrChange` elements carry the old properties and revision through the round trip.
#[test]
fn tracked_style_definition_change_round_trips() {
let mut d = Document::new();
d.revisions.push(Revision { kind: RevisionKind::Format, author: "Ana".into(), date: "2026-10-17T10:00:00Z".into(), move_name: None });
std::sync::Arc::make_mut(&mut d.styles).upsert(Style {
id: "Mine".into(),
name: "Mine".into(),
kind: StyleKind::Paragraph,
para: ParaProps { align: Some(Align::Center), ..Default::default() },
chr: CharProps { bold: Some(true), size: Some(14.0), ..Default::default() },
para_change: PropChange::boxed(0, ParaProps { align: Some(Align::Right), ..Default::default() }),
chr_change: PropChange::boxed(0, CharProps { italic: Some(true), ..Default::default() }),
..Default::default()
});
d.body = vec![para_block(Paragraph::with_text("x", CharProps::default()))];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/styles.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains("<w:pPrChange") && xml.contains("<w:rPrChange"), "{xml}");
assert!(!xml.contains("stylePrChange"), "CT_Style has no such element: {xml}");
drop(zip);
let r = wordcraft_docx::read(&bytes).expect("read");
let st = r.styles.get("Mine").expect("the style");
let para = st.para_change.as_ref().expect("the paragraph change survives");
let chr = st.chr_change.as_ref().expect("the run change survives");
assert_eq!((st.para.align, para.old.align), (Some(Align::Center), Some(Align::Right)));
assert_eq!(st.chr.bold, Some(true));
assert_eq!((chr.old.italic, chr.old.bold), (Some(true), None), "the style as it was");
assert_eq!(r.revisions.get(chr.rev as usize).map(|x| (x.kind, x.author.as_str())), Some((RevisionKind::Format, "Ana")));
}
#[test]
fn tables_with_merges_round_trip() {
let mut t = Table::new(3, 3, 468.0);
t.props.width = Some(468.0);
t.props.align = Some(Align::Center);
t.props.indent = Some(5.0);
t.props.borders = Some(Borders::all(Border::single(0.5)));
t.props.cell_margins = Some([1.0, 5.4, 1.0, 5.4]);
t.props.fixed = true;
t.props.look = TableLook { header_row: true, total_row: true, banded_rows: false, first_column: false, last_column: true, banded_columns: true };
t.props.shading = Some(Rgb(1, 1, 1));
t.props.caption = Some("Sales".into());
t.rows[0].props = RowProps { height: Some(20.0), height_rule: HeightRule::Exact, header: true, cant_split: true, ..Default::default() };
t.rows[1].props = RowProps { height: Some(15.0), height_rule: HeightRule::AtLeast, ..Default::default() };
t.merge(0, 0, 0, 1); // horizontal
t.merge(1, 2, 2, 2); // vertical
{
let c = &mut t.rows[1].cells[0];
c.props.shading = Some(Rgb(0xFF, 0, 0));
c.props.valign = Some(VAlign::Bottom);
c.props.text_direction = TextDirection::Up;
c.props.no_wrap = true;
c.props.margins = Some([2.0, 3.0, 4.0, 5.0]);
c.props.width = None;
c.props.width_pct = Some(40.0);
c.props.borders = Some(Borders::box_(Border { style: BorderStyle::Dashed, width: 1.0, color: Some(Rgb(0, 0, 255)), space: 0.0 }));
c.blocks = vec![para_block(Paragraph::with_text("red", CharProps::default()))];
}
// Nested table in a cell (followed by the required paragraph).
let inner = Table::new(1, 2, 100.0);
t.rows[2].cells[0].blocks = vec![Arc::new(Block::Table(inner)), para_block(Paragraph::new())];
let mut d = Document::new();
d.body = vec![para_block(Paragraph::with_text("before", CharProps::default())), Arc::new(Block::Table(t.clone())), para_block(Paragraph::new())];
let r = rt(&d);
let got = r.body[1].as_table().expect("table");
assert_eq!(got.props, t.props);
assert_eq!(got.grid, t.grid);
assert_eq!(got.rows.len(), 3);
for (gr, er) in got.rows.iter().zip(&t.rows) {
assert_eq!(gr.props, er.props);
assert_eq!(gr.cells.len(), er.cells.len());
for (gc, ec) in gr.cells.iter().zip(&er.cells) {
assert_eq!(gc.props, ec.props);
assert_eq!(gc.blocks, ec.blocks);
}
}
assert_eq!(got.rows[0].cells[0].span(), 2);
assert_eq!(got.rows[2].cells[2].props.vmerge, VMerge::Continue);
}
#[test]
fn sections_headers_footers_round_trip() {
let mut d = Document::new();
let page = |instr: &str| {
let mut p = Paragraph::with_text("Page ", CharProps::default());
p.insert_object(
5,
InlineObject::Field { instr: instr.into(), result: "1".into(), locked: false, dirty: false, code: false, form: String::new() },
&CharProps::default(),
)
.unwrap();
p
};
let h1 = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Header one", CharProps::default()))]);
let hf = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("First page header", CharProps::default()))]);
let f1 = d.add_part(PartKind::Footer, vec![para_block(page("PAGE"))]);
let f2 = d.add_part(PartKind::Footer, vec![para_block(page("NUMPAGES"))]);
let mut s1 = SectionProps {
title_page: true,
page_num_start: Some(3),
page_num_format: NumFormat::UpperRoman,
valign: PageVAlign::Center,
page_borders: Some(Borders::box_(Border::single(1.0))),
line_numbers: Some(LineNumbering { count_by: 5, start: 1, distance: 18.0, restart: LineNumberRestart::Section }),
gutter: 18.0,
// #391: a line and character grid (Word writes `w:docGrid` even without a grid).
doc_grid: Some(DocGrid { kind: DocGridType::LinesAndChars, line_pitch: 17.5, char_space: -1843 }),
..Default::default()
};
s1.headers.default = Some(h1);
s1.headers.first = Some(hf);
s1.footers.default = Some(f1);
let mut s2 = SectionProps { start: SectionStart::OddPage, rtl: true, doc_grid: Some(DocGrid::default()), ..Default::default() };
s2.set_landscape(true);
s2.columns = Columns { count: 2, space: 24.0, separator: true, widths: Vec::new() };
s2.footers.default = Some(f2);
s2.headers.default = Some(h1);
let mut p1 = Paragraph::with_text("Section one", CharProps::default());
p1.section = Some(Box::new(s1.clone()));
let mut s3 = SectionProps { start: SectionStart::Continuous, ..Default::default() };
s3.columns = Columns { count: 2, space: 10.0, separator: false, widths: vec![(200.0, 20.0), (248.0, 0.0)] };
let mut p2 = Paragraph::with_text("Section two", CharProps::default());
p2.section = Some(Box::new(s2.clone()));
d.body = vec![para_block(p1), para_block(p2), para_block(Paragraph::with_text("Last", CharProps::default()))];
d.last_section = s3.clone();
let r = rt(&d);
let secs = r.sections();
assert_eq!(secs.len(), 3);
let strip = |s: &SectionProps| SectionProps { headers: Default::default(), footers: Default::default(), ..s.clone() };
assert_eq!(strip(secs[0].1), strip(&s1));
assert_eq!(strip(secs[1].1), strip(&s2));
assert_eq!(strip(secs[2].1), strip(&s3));
assert!(secs[1].1.landscape);
assert_eq!(part_text(&r, secs[0].1.headers.default), "Header one");
assert_eq!(part_text(&r, secs[0].1.headers.first), "First page header");
assert_eq!(secs[0].1.headers.default, secs[1].1.headers.default, "shared header part stays shared");
let fp = r.parts.get(&secs[0].1.footers.default.unwrap()).unwrap().blocks[0].as_para().unwrap();
assert_eq!(
fp.objects,
vec![InlineObject::Field { instr: "PAGE".into(), result: "1".into(), locked: false, dirty: false, code: false, form: String::new() }]
);
assert_eq!(part_text(&r, secs[1].1.footers.default), "Page 1");
assert_eq!(r.parts.get(&secs[0].1.headers.default.unwrap()).unwrap().kind, PartKind::Header);
}
#[test]
fn images_round_trip() {
let mut d = Document::new();
let png = tiny_png();
let key = d.add_media(png.clone(), "png");
let inline = InlineObject::Image {
media: key.clone(),
w: 72.0,
h: 48.0,
alt: "A tiny picture".into(),
// Room for a shadow: kept through save and load.
float: Float { effect: [12.0, 12.0, 27.0, 27.0], ..Default::default() },
crop: [0.1, 0.0, 0.25, 0.05],
fx: Default::default(),
ole: None,
};
let floating = InlineObject::Image {
media: key.clone(),
w: 100.0,
h: 50.0,
alt: String::new(),
float: Float { wrap: Wrap::Square, h_rel: Anchor::Page, v_rel: Anchor::Margin, x: 36.0, y: 12.5, dist: 9.0, ..Default::default() },
crop: [0.0; 4],
fx: Default::default(),
ole: None,
};
let aligned = InlineObject::Image {
media: key.clone(),
w: 20.0,
h: 20.0,
alt: String::new(),
float: Float {
wrap: Wrap::Square,
h_rel: Anchor::RightMargin,
h_align: Some(FloatAlign::Center),
v_rel: Anchor::TopMargin,
v_align: Some(FloatAlign::End),
dist: 9.0,
dist_top: 2.5,
dist_bottom: 4.0,
..Default::default()
},
crop: [0.0; 4],
fx: Default::default(),
ole: None,
};
let mut floats = vec![floating.clone(), aligned];
for wrap in [Wrap::Tight, Wrap::Through, Wrap::TopAndBottom, Wrap::BehindText, Wrap::InFrontOfText] {
floats.push(InlineObject::Image {
media: key.clone(),
w: 10.0,
h: 10.0,
alt: String::new(),
float: Float { wrap, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 0.0, y: 0.0, dist: 0.0, ..Default::default() },
crop: [0.0; 4],
fx: Default::default(),
ole: None,
});
}
let mut p = Paragraph::with_text("pic: ", CharProps::default());
p.insert_object(5, inline.clone(), &CharProps::default()).unwrap();
for f in &floats {
let end = p.len();
p.insert_object(end, f.clone(), &CharProps::default()).unwrap();
}
d.body = vec![para_block(p)];
let r = unstacked(rt(&d));
let got = paras(&r)[0];
let mut expect = vec![inline];
expect.extend(floats);
assert_eq!(got.objects, expect);
assert_eq!(r.media.get(&key).map(|b| b.as_slice()), Some(png.as_slice()));
assert_eq!(r.media.len(), 1);
}
#[test]
fn hyperlinks_and_bookmarks_round_trip() {
let ext = CharProps { link: Some("https://example.com/a?b=1&c=2".into()), underline: Some(Underline::Single), ..Default::default() };
let int = CharProps { link: Some("#target".into()), ..Default::default() };
let mut p = para_runs(&[("see ", CharProps::default()), ("example", ext.clone()), (" and ", CharProps::default()), ("here", int.clone())]);
p.insert_object(0, InlineObject::BookmarkStart { name: "target".into() }, &CharProps::default()).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::BookmarkEnd { name: "target".into() }, &CharProps::default()).unwrap();
let d = doc_with(vec![p.clone()]);
let r = rt(&d);
let got = paras(&r)[0];
assert_eq!(got.text, p.text);
assert_eq!(got.objects, p.objects);
assert_eq!(got.props_of_char(got.text.find("example").unwrap()), &ext);
assert_eq!(got.props_of_char(got.text.find("here").unwrap()), &int);
assert_eq!(r.bookmarks().len(), 1);
}
#[test]
fn comments_round_trip() {
let mut d = Document::new();
let c0 = d.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text("Please check this.", CharProps::default()))]);
let c1 = d.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text("Done.", CharProps::default()))]);
d.comments.insert(
0,
Comment {
author: "Ann".into(),
initials: "A".into(),
date: "2026-01-02T03:04:05Z".into(),
parent: None,
resolved: true,
part: c0,
..Default::default()
},
);
d.comments.insert(
1,
Comment {
author: "Ben".into(),
initials: "B".into(),
date: "2026-01-03T00:00:00Z".into(),
parent: Some(0),
resolved: false,
part: c1,
..Default::default()
},
);
let mut p = Paragraph::with_text("commented text", CharProps::default());
p.insert_object(0, InlineObject::CommentStart { id: 0 }, &CharProps::default()).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::CommentEnd { id: 0 }, &CharProps::default()).unwrap();
d.body = vec![para_block(p.clone())];
let r = rt(&d);
assert_eq!(paras(&r)[0].objects, p.objects);
assert_eq!(r.comments.len(), 2);
for (id, c) in &d.comments {
let g = r.comments.get(id).expect("comment");
assert_eq!((&g.author, &g.initials, &g.date, g.parent, g.resolved), (&c.author, &c.initials, &c.date, c.parent, c.resolved));
assert_eq!(part_text(&r, Some(g.part)), part_text(&d, Some(c.part)));
assert_eq!(r.parts.get(&g.part).unwrap().kind, PartKind::Comment);
}
}
/// A table style's cell text formatting, whole-table shading, cell margins and its header row and
/// row band conditional formats (#146) survive a save.
#[test]
fn table_style_formatting_round_trips() {
use wordcraft_doc::styles::TableStyleParts;
let mut d = doc_with(vec![Paragraph::with_text("x", CharProps::default())]);
let parts = TableStyleParts {
borders: Some(Borders { top: Some(Border::single(1.0)), ..Default::default() }),
fill: Some(Rgb(0xDD, 0xEB, 0xF7)),
cell_margins: Some([1.0, 14.4, 0.0, 14.4]),
header_chr: CharProps { italic: Some(true), ..Default::default() },
header_fill: Some(Rgb(0xFF, 0xFF, 0)),
header_borders: Some(Borders::all(Border::single(1.5))),
band_fill: Some(Rgb(0xF2, 0xF2, 0xF2)),
band_chr: CharProps { bold: Some(true), color: Some(TextColor::Rgb(Rgb(0, 0x70, 0xC0))), ..Default::default() },
band_borders: Some(Borders::box_(Border { style: BorderStyle::None, width: 0.0, color: None, space: 0.0 })),
band_size: Some(3),
..Default::default()
};
Arc::make_mut(&mut d.styles).upsert(Style {
id: "Whole".into(),
name: "Whole".into(),
kind: StyleKind::Table,
based_on: Some("TableGrid".into()),
para: ParaProps { align: Some(Align::Center), space_after: Some(0.0), ..Default::default() },
chr: CharProps { bold: Some(true), color: Some(TextColor::Rgb(Rgb(0xC0, 0, 0))), ..Default::default() },
table: Some(parts.clone()),
..Default::default()
});
let r = rt(&d);
let got = r.styles.get("Whole").unwrap();
assert_eq!(got.based_on.as_deref(), Some("TableGrid"));
assert_eq!(got.para.align, Some(Align::Center));
assert_eq!(got.para.space_after, Some(0.0));
assert_eq!((got.chr.bold, got.chr.color), (Some(true), Some(TextColor::Rgb(Rgb(0xC0, 0, 0)))));
assert_eq!(got.table.as_ref(), Some(&parts));
}
/// #714: every table style part (ECMA-376 §17.7.6 `w:tblStylePr` types) keeps its run
/// formatting, cell shading, cell borders and horizontal and vertical alignment through a save.
#[test]
fn every_table_style_part_round_trips() {
use wordcraft_doc::styles::{PartFormat, TablePart};
let mut d = doc_with(vec![Paragraph::with_text("x", CharProps::default())]);
let mut st = Style { id: "Parts".into(), name: "Parts".into(), kind: StyleKind::Table, based_on: Some("TableGrid".into()), ..Default::default() };
let aligns = [Align::Left, Align::Center, Align::Right];
let valigns = [VAlign::Top, VAlign::Center, VAlign::Bottom];
for (i, part) in TablePart::ALL.into_iter().enumerate() {
let n = i as u8;
let f = PartFormat {
chr: CharProps {
bold: Some(i % 2 == 0),
italic: Some(i % 3 == 0),
underline: (i % 4 == 0).then_some(Underline::Single),
size: Some(8.0 + i as f32),
font: Some(format!("Face {i}")),
color: Some(TextColor::Rgb(Rgb(n, 0x20, 0x40))),
..Default::default()
},
fill: Some(Rgb(0x10 + n, 0x80, 0xF0 - n)),
borders: Some(Borders {
top: Some(Border { style: BorderStyle::Double, width: 1.5, color: Some(Rgb(n, 0, 0)), space: 0.0 }),
bottom: Some(Border::single(0.5 + i as f32 / 4.0)),
left: Some(Border { style: BorderStyle::None, width: 0.0, color: None, space: 0.0 }),
inside_v: (i % 2 == 1).then(|| Border::single(0.25)),
..Default::default()
}),
align: aligns.get(i % 3).copied(),
v_align: valigns.get(i % 3).copied(),
};
st.set_table_part(part, f);
}
Arc::make_mut(&mut d.styles).upsert(st.clone());
let r = rt(&d);
let got = r.styles.get("Parts").unwrap();
for part in TablePart::ALL {
assert_eq!(got.table_part(part), st.table_part(part), "{}", part.ooxml());
}
assert_eq!(got.table, st.table);
}
#[test]
fn notes_round_trip() {
let mut d = Document::new();
let f = d.add_part(PartKind::Footnote, vec![para_block(Paragraph::with_text("A footnote.", CharProps::default()))]);
let f2 = d.add_part(PartKind::Footnote, vec![para_block(Paragraph::with_text("Custom.", CharProps::default()))]);
let e = d.add_part(
PartKind::Endnote,
vec![
para_block(Paragraph::with_text("An endnote.", CharProps::default())),
para_block(Paragraph::with_text("Second para.", CharProps::default())),
],
);
let mut p = Paragraph::with_text("Text", CharProps::default());
let sup = CharProps { vert_align: Some(VertAlign::Superscript), ..Default::default() };
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &sup).unwrap();
p.insert_object(1, InlineObject::NoteRef { kind: NoteKind::Endnote, id: e, custom: String::new() }, &sup).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f2, custom: "*".into() }, &sup).unwrap();
d.settings.footnote_format = NumFormat::LowerLetter;
d.settings.endnote_format = NumFormat::UpperRoman;
d.body = vec![para_block(p.clone())];
let r = rt(&d);
let got = paras(&r)[0];
assert_eq!(got.text, p.text);
assert_eq!(got.runs, p.runs);
let notes: Vec<(NoteKind, String, String)> = got
.objects
.iter()
.map(|o| match o {
InlineObject::NoteRef { kind, id, custom } => (*kind, part_text(&r, Some(*id)), custom.clone()),
o => panic!("unexpected {o:?}"),
})
.collect();
assert_eq!(
notes,
vec![
(NoteKind::Endnote, "An endnote.\nSecond para.".into(), String::new()),
(NoteKind::Footnote, "A footnote.".into(), String::new()),
(NoteKind::Footnote, "Custom.".into(), "*".into()),
]
);
assert_eq!(r.settings.footnote_format, NumFormat::LowerLetter);
assert_eq!(r.settings.endnote_format, NumFormat::UpperRoman);
}
/// #385: footnote and endnote options round-trip for the document (settings) and per section
/// (`w:sectPr`), in schema order: `w:footnotePr` and `w:endnotePr` before `w:type`.
#[test]
fn note_options_round_trip_per_section() {
use wordcraft_doc::section::{NotePos, NoteProps, NoteRestart};
let mut d = Document::new();
d.settings.footnote_format = NumFormat::UpperLetter;
d.settings.footnote_pr =
NoteProps { pos: Some(NotePos::BeneathText), num_start: Some(4), num_restart: Some(NoteRestart::EachPage), ..Default::default() };
d.settings.endnote_pr = NoteProps { pos: Some(NotePos::SectEnd), ..Default::default() };
let mut first = Paragraph::with_text("Section one", CharProps::default());
let own = NoteProps { num_fmt: Some(NumFormat::LowerRoman), num_start: Some(7), num_restart: Some(NoteRestart::EachSect), ..Default::default() };
first.section = Some(Box::new(SectionProps {
footnote_pr: own,
endnote_pr: NoteProps { num_fmt: Some(NumFormat::Decimal), ..Default::default() },
..Default::default()
}));
d.body = vec![para_block(first), para_block(Paragraph::with_text("Section two", CharProps::default()))];
let bytes = wordcraft_docx::write(&d).unwrap();
let r = wordcraft_docx::read(&bytes).unwrap();
assert_eq!(r.settings.footnote_format, NumFormat::UpperLetter);
assert_eq!((r.settings.footnote_pr, r.settings.endnote_pr), (d.settings.footnote_pr, d.settings.endnote_pr));
let sections = r.sections();
assert_eq!(sections[0].1.footnote_pr, own);
assert_eq!(sections[0].1.endnote_pr.num_fmt, Some(NumFormat::Decimal));
assert!(sections[1].1.footnote_pr.is_empty() && sections[1].1.endnote_pr.is_empty());
assert_eq!(r.note_options(sections[0].1, false).num_start, 7);
assert_eq!(r.note_options(sections[1].1, false).num_start, 4);
let mut z = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(z.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
let at = |s: &str| xml.find(s).unwrap_or_else(|| panic!("{s} missing"));
assert!(
at("<w:footnotePr><w:numFmt w:val=\"lowerRoman\"/><w:numStart w:val=\"7\"/><w:numRestart w:val=\"eachSect\"/></w:footnotePr>")
< at("<w:type")
);
}
/// `references.footnote` starts the note's own text with a reference to the note, so the editor shows
/// its number. In the file that is the `w:footnoteRef` mark; a `w:footnoteReference` there would make
/// the note cite itself, which LibreOffice refuses to open.
#[test]
fn note_never_references_itself() {
let mut d = Document::new();
let f = d.add_part(PartKind::Footnote, Vec::new());
let mut note = Paragraph::with_text(" The note.", CharProps::default());
note.insert_object(0, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
d.parts.get_mut(&f).unwrap().blocks = vec![para_block(note)];
let mut p = Paragraph::with_text("Text", CharProps::default());
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/footnotes.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(!xml.contains("<w:footnoteReference"), "a footnote cites itself: {xml}");
assert_eq!(xml.matches("<w:footnoteRef/>").count(), 1, "{xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let got = paras(&r)[0];
let Some(InlineObject::NoteRef { id, .. }) = got.objects.first() else { panic!("{:?}", got.objects) };
assert_eq!(part_text(&r, Some(*id)).trim(), "The note.");
}
/// A note with a custom mark keeps it in the note's own text: a plain run with the mark, not the
/// `w:footnoteRef` / `w:endnoteRef` placeholder that Word replaces by the automatic number.
#[test]
fn custom_note_mark_stays_in_the_note() {
let mut d = Document::new();
let f = d.add_part(PartKind::Footnote, Vec::new());
let e = d.add_part(PartKind::Endnote, Vec::new());
for (id, kind) in [(f, NoteKind::Footnote), (e, NoteKind::Endnote)] {
let mut note = Paragraph::with_text(" The note.", CharProps::default());
note.insert_object(0, InlineObject::NoteRef { kind, id, custom: "*".into() }, &CharProps::default()).unwrap();
d.parts.get_mut(&id).unwrap().blocks = vec![para_block(note)];
}
let mut p = Paragraph::with_text("Text", CharProps::default());
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: "*".into() }, &CharProps::default()).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::NoteRef { kind: NoteKind::Endnote, id: e, custom: "*".into() }, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
let bytes = wordcraft_docx::write(&d).expect("write");
for (file, mark) in [("word/footnotes.xml", "<w:footnoteRef/>"), ("word/endnotes.xml", "<w:endnoteRef/>")] {
let xml = part_xml(&bytes, file);
assert!(!xml.contains(mark), "{file}: the custom mark became an automatic number: {xml}");
assert!(xml.contains(r#"<w:t xml:space="preserve">*</w:t>"#), "{file}: {xml}");
}
}
/// A note read from a Word file starts with its own number (a reference to itself, from the
/// `w:footnoteRef` mark). Saving writes that mark back exactly once, with its character style, and
/// never as a `w:footnoteReference`; reading the saved file gives the same note again.
#[test]
fn word_note_mark_round_trips_once() {
let mut d = Document::new();
let f = d.add_part(PartKind::Footnote, Vec::new());
let e = d.add_part(PartKind::Endnote, Vec::new());
for (id, kind, style) in [(f, NoteKind::Footnote, "FootnoteReference"), (e, NoteKind::Endnote, "EndnoteReference")] {
let mut note =
Paragraph::with_text(" The note.", CharProps::default()).styled(if kind == NoteKind::Footnote { "FootnoteText" } else { "EndnoteText" });
note.insert_object(
0,
InlineObject::NoteRef { kind, id, custom: String::new() },
&CharProps { style: Some(style.into()), ..Default::default() },
)
.unwrap();
// A second paragraph: the mark is not repeated there.
d.parts.get_mut(&id).unwrap().blocks = vec![para_block(note), para_block(Paragraph::with_text("More.", CharProps::default()))];
}
let mut p = Paragraph::with_text("Text", CharProps::default());
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::NoteRef { kind: NoteKind::Endnote, id: e, custom: String::new() }, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
let mut doc = d;
for pass in 0..2 {
let bytes = wordcraft_docx::write(&doc).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
for (file, mark, reference, style) in [
("word/footnotes.xml", "<w:footnoteRef/>", "<w:footnoteReference", "FootnoteReference"),
("word/endnotes.xml", "<w:endnoteRef/>", "<w:endnoteReference", "EndnoteReference"),
] {
let xml = String::from_utf8(zip.read(file, 16 << 20).unwrap().unwrap()).unwrap();
assert_eq!(xml.matches(mark).count(), 1, "pass {pass}: {xml}");
assert!(!xml.contains(reference), "pass {pass}: a note cites itself: {xml}");
assert!(xml.contains(&format!(r#"<w:rStyle w:val="{style}"/></w:rPr>{mark}"#)), "pass {pass}: {xml}");
}
let r = wordcraft_docx::read(&bytes).expect("read");
let body = paras(&r)[0];
assert_eq!(body.objects.len(), 2, "pass {pass}");
for o in &body.objects {
let InlineObject::NoteRef { kind, id, .. } = o else { panic!("{o:?}") };
let blocks = &r.parts.get(id).unwrap().blocks;
assert_eq!(blocks.len(), 2, "pass {pass}");
let first = blocks[0].as_para().unwrap();
assert_eq!(first.objects, vec![InlineObject::NoteRef { kind: *kind, id: *id, custom: String::new() }], "pass {pass}");
assert_eq!(first.plain_text(), " The note.");
assert!(blocks[1].as_para().unwrap().objects.is_empty(), "pass {pass}");
}
doc = r;
}
}
/// The TOC is a `Contents` paragraph ending in an empty `TOC` field, followed by TOC-styled entries.
/// In the file the field must contain the entries, inside Word's Table of Contents content control,
/// or Word shows them as plain text with no Update Table.
#[test]
fn toc_field_wraps_its_entries() {
for entries in [&[("Intro\t1", "TOC1")][..], &[("Intro\t1", "TOC1"), ("Detail\t2", "TOC2")][..]] {
let mut head = Paragraph::with_text("Contents", CharProps::default()).styled("TOCHeading");
let end = head.len();
head.insert_object(
end,
InlineObject::Field {
instr: "TOC \\o \"1-2\" \\h \\z \\u".into(),
result: String::new(),
locked: false,
dirty: false,
code: false,
form: String::new(),
},
&CharProps::default(),
)
.unwrap();
let mut blocks = vec![head];
blocks.extend(entries.iter().map(|(t, st)| Paragraph::with_text(t, CharProps::default()).styled(st)));
blocks.push(Paragraph::with_text("Body", CharProps::default()));
let d = doc_with(blocks);
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
let sdt = xml.find("<w:sdt>").expect("TOC content control");
assert!(xml.contains(r#"<w:docPartGallery w:val="Table of Contents"/>"#), "{xml}");
let (begin, fend) = (xml.find(r#"fldCharType="begin""#).unwrap(), xml.find(r#"fldCharType="end""#).unwrap());
let last_entry = xml.find(entries.last().unwrap().0.split('\t').next().unwrap()).unwrap();
assert!(sdt < xml.find("Contents").unwrap() && xml.find("</w:sdt>").unwrap() < xml.find(">Body<").unwrap(), "{xml}");
assert!(
begin < xml.find("Intro").unwrap() && fend > last_entry && fend < xml.find("</w:sdt>").unwrap(),
"field must span the entries: {xml}"
);
// Word starts the field in the first entry; started in the heading, LibreOffice splits the heading.
let heading_end = xml[..xml.find("Intro").unwrap()].rfind("</w:p>").unwrap();
assert!(begin > heading_end, "field must start in the first entry, not the heading: {xml}");
// WordCraft reads its own TOC back unchanged.
let r = wordcraft_docx::read(&bytes).expect("read");
let ps = paras(&r);
let expected: Vec<_> = std::iter::once("Contents").chain(entries.iter().map(|(t, _)| *t)).chain(std::iter::once("Body")).collect();
assert_eq!(ps.iter().map(|p| p.plain_text()).collect::<Vec<_>>(), expected);
assert!(matches!(ps[0].objects.first(), Some(InlineObject::Field { instr, .. }) if instr.starts_with("TOC")), "{:?}", ps[0].objects);
assert!(ps[1].objects.is_empty(), "the field goes back on the heading: {:?}", ps[1].objects);
assert_eq!(ps[1].props.style.as_deref(), Some("TOC1"));
}
}
/// Table Layout › Text Direction (#226): each direction is written as Word's `w:textDirection`
/// value and read back.
#[test]
fn cell_text_direction_round_trips() {
let mut t = Table::new(1, 3, 300.0);
let dirs = [TextDirection::Horizontal, TextDirection::Down, TextDirection::Up];
for (c, dir) in t.rows[0].cells.iter_mut().zip(dirs) {
c.props.text_direction = dir;
}
let mut d = Document::new();
d.body = vec![Arc::new(Block::Table(t)), para_block(Paragraph::new())];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<w:textDirection w:val="tbRl"/>"#), "{xml}");
assert!(xml.contains(r#"<w:textDirection w:val="btLr"/>"#), "{xml}");
assert_eq!(xml.matches("w:textDirection").count(), 2, "horizontal cells write nothing: {xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let got: Vec<TextDirection> = r.body[0].as_table().expect("table").rows[0].cells.iter().map(|c| c.props.text_direction).collect();
assert_eq!(got, dirs);
}
/// The TOC field's begin and end belong to the entries' own paragraphs, even when the heading or
/// an entry holds a text box: the box's paragraphs are written inside them and must not take either.
#[test]
fn toc_field_skips_nested_stories() {
let mut d = Document::new();
let text_box = |d: &mut Document, text: &str| {
let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text(text, CharProps::default()))]);
InlineObject::Shape {
kind: ShapeKind::TextBox,
w: 72.0,
h: 36.0,
fill: None,
stroke: None,
stroke_width: 0.0,
float: Float::default(),
story: Some(story),
freeform: None,
effects: Default::default(),
extra: Default::default(),
}
};
let mut head = Paragraph::with_text("Contents", CharProps::default()).styled("TOCHeading");
let end = head.len();
head.insert_object(
end,
InlineObject::Field {
instr: "TOC \\o \"1-1\" \\h \\z \\u".into(),
result: String::new(),
locked: false,
dirty: false,
code: false,
form: String::new(),
},
&CharProps::default(),
)
.unwrap();
let end = head.len();
head.insert_object(end, text_box(&mut d, "Heading box"), &CharProps::default()).unwrap();
let mut last = Paragraph::with_text("Detail\t2", CharProps::default()).styled("TOC1");
let end = last.len();
last.insert_object(end, text_box(&mut d, "Boxed"), &CharProps::default()).unwrap();
d.body = vec![para_block(head), para_block(last), para_block(Paragraph::with_text("Body", CharProps::default()))];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
let boxes: Vec<(usize, usize)> = xml.match_indices("<w:txbxContent>").map(|(a, _)| (a, a + xml[a..].find("</w:txbxContent>").unwrap())).collect();
// Each text box is written twice: in the drawing and in its VML fallback.
assert_eq!(boxes.len(), 4, "{xml}");
let in_box = |i: usize| boxes.iter().any(|(a, b)| (*a..*b).contains(&i));
for kind in ["begin", "separate", "end"] {
let at: Vec<usize> = xml.match_indices(&format!(r#"fldCharType="{kind}""#)).map(|(i, _)| i).collect();
assert_eq!(at.len(), 1, "{kind}: {xml}");
assert!(!in_box(at[0]), "field {kind} written inside a text box: {xml}");
}
let (begin, end) = (xml.find(r#"fldCharType="begin""#).unwrap(), xml.find(r#"fldCharType="end""#).unwrap());
assert!(begin > boxes[1].1 && end > boxes[3].1 && end < xml.find("</w:sdt>").unwrap(), "{xml}");
}
#[test]
fn tracked_changes_round_trip() {
let mut d = Document::new();
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "Alice".into(), date: "2026-05-01T10:00:00Z".into(), move_name: None });
d.revisions.push(Revision { kind: RevisionKind::Delete, author: "Bob".into(), date: "2026-05-02T10:00:00Z".into(), move_name: None });
d.settings.track_changes = true;
let ins = CharProps { ins: Some(0), ..Default::default() };
let del = CharProps { del: Some(1), bold: Some(true), ..Default::default() };
let both = CharProps { ins: Some(0), del: Some(1), ..Default::default() };
let p = para_runs(&[("kept ", CharProps::default()), ("added\t", ins.clone()), ("removed", del.clone()), ("gone", both.clone())]);
let mut p = p;
let end = p.len();
p.insert_object(
end,
InlineObject::Field { instr: "DATE".into(), result: "today".into(), locked: false, dirty: false, code: false, form: String::new() },
&del,
)
.unwrap();
d.body = vec![para_block(p.clone())];
let r = rt(&d);
assert_eq!(r.revisions, d.revisions);
let got = paras(&r)[0];
assert_eq!(got.text, p.text);
assert_eq!(got.runs, p.runs);
assert_eq!(got.objects, p.objects);
assert!(r.settings.track_changes);
}
#[test]
fn tracked_equations_round_trip() {
// Issue #6011: equations saved with tracked revision marks (w:ins / w:del) around math.
let mut d = Document::new();
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "Alice".into(), date: "2026-05-01T10:00:00Z".into(), move_name: None });
d.revisions.push(Revision { kind: RevisionKind::Delete, author: "Bob".into(), date: "2026-05-02T10:00:00Z".into(), move_name: None });
d.settings.track_changes = true;
let ins = CharProps { ins: Some(0), ..Default::default() };
let del = CharProps { del: Some(1), ..Default::default() };
let plain = CharProps::default();
let mut p = Paragraph::with_text("Formula: ", CharProps::default());
let end = p.len();
p.insert_object(end, InlineObject::Equation { linear: "x+1".into(), display: false, math: Default::default() }, &ins).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::Equation { linear: "E=mc^2".into(), display: true, math: Default::default() }, &del).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::Equation { linear: "a^2+b^2=c^2".into(), display: true, math: Default::default() }, &ins).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::Equation { linear: "y=mx+b".into(), display: false, math: Default::default() }, &del).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::Equation { linear: "z=1".into(), display: false, math: Default::default() }, &plain).unwrap();
d.body = vec![para_block(p.clone())];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<w:ins w:id="1" w:author="Alice" w:date="2026-05-01T10:00:00Z"><m:oMath>"#), "ins directly encloses inline math: {xml}");
assert!(
xml.contains(r#"<w:del w:id="2" w:author="Bob" w:date="2026-05-02T10:00:00Z"><m:oMathPara>"#),
"del directly encloses display math: {xml}"
);
assert!(
xml.contains(r#"<w:ins w:id="3" w:author="Alice" w:date="2026-05-01T10:00:00Z"><m:oMathPara>"#),
"ins directly encloses display math: {xml}"
);
assert!(xml.contains(r#"<w:del w:id="4" w:author="Bob" w:date="2026-05-02T10:00:00Z"><m:oMath>"#), "del directly encloses inline math: {xml}");
assert!(xml.contains(r#"</w:del><m:oMath>"#), "plain equation follows closing tag without revision wrapper: {xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
assert_eq!(r.revisions, d.revisions);
let got = ¶s(&r)[0];
assert_eq!(got.objects.len(), 5);
let eq_summary: Vec<(bool, String)> = got
.objects
.iter()
.map(|o| match o {
InlineObject::Equation { display, linear, .. } => (*display, linear.clone()),
_ => panic!("expected equation object, got {o:?}"),
})
.collect();
assert_eq!(
eq_summary,
vec![(false, "x+1".into()), (true, "E=mc^2".into()), (true, "a^2+b^2=c^2".into()), (false, "y=mx+b".into()), (false, "z=1".into()),]
);
assert_eq!(got.runs, p.runs);
}
#[test]
fn nested_omath_para_revisions_read() {
// Defensive reader check: w:ins and w:del nested inside m:oMathPara.
let mut d = Document::new();
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "Ada".into(), date: "2026-05-01T10:00:00Z".into(), move_name: None });
d.revisions.push(Revision { kind: RevisionKind::Delete, author: "Charles".into(), date: "2026-05-02T10:00:00Z".into(), move_name: None });
let doc_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"><w:body><w:p><m:oMathPara><w:ins w:id="1" w:author="Ada" w:date="2026-05-01T10:00:00Z"><m:oMath><m:r><m:t>x+1</m:t></m:r></m:oMath></w:ins><w:del w:id="2" w:author="Charles" w:date="2026-05-02T10:00:00Z"><m:oMath><m:r><m:t>y-1</m:t></m:r></m:oMath></w:del></m:oMathPara></w:p></w:body></w:document>"#;
let base = wordcraft_docx::write(&d).unwrap();
let bytes = replace_part(&base, "word/document.xml", doc_xml.as_bytes());
let r = wordcraft_docx::read(&bytes).expect("read");
let got = ¶s(&r)[0];
assert_eq!(got.objects.len(), 2);
assert!(matches!(&got.objects[0], InlineObject::Equation { display: true, linear, .. } if linear == "x+1"));
assert!(matches!(&got.objects[1], InlineObject::Equation { display: true, linear, .. } if linear == "y-1"));
assert_eq!(got.runs[0].props.ins, Some(0));
assert_eq!(got.runs[1].props.del, Some(1));
}
#[test]
fn tracked_paragraph_marks_round_trip() {
// Issue #229: an inserted / deleted paragraph mark is `w:ins` / `w:del` in the mark's
// `w:rPr` (ECMA-376 §17.13.5.16, §17.13.5.15), alone or with mark formatting.
let mut d = Document::new();
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "Alice".into(), date: "2026-05-01T10:00:00Z".into(), move_name: None });
d.revisions.push(Revision { kind: RevisionKind::Delete, author: "Bob".into(), date: "2026-05-02T10:00:00Z".into(), move_name: None });
let mut split = Paragraph::with_text("Owned ALPHA ", CharProps::default());
split.mark.ins = Some(0);
let mut joined = Paragraph::with_text("Owned BETA", CharProps::default());
joined.mark = CharProps { bold: Some(true), del: Some(1), ..Default::default() };
let last = Paragraph::with_text("plain", CharProps::default());
d.body = vec![para_block(split), para_block(joined), para_block(last)];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<w:rPr><w:ins w:id="#), "{xml}");
assert!(xml.contains(r#"<w:rPr><w:del w:id="#), "{xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let got = paras(&r);
assert_eq!(got.len(), 3);
let rev = |i: Option<u32>| i.and_then(|i| r.revisions.get(i as usize)).map(|v| (v.kind, v.author.as_str(), v.date.as_str()));
assert_eq!(rev(got[0].mark.ins), Some((RevisionKind::Insert, "Alice", "2026-05-01T10:00:00Z")));
assert_eq!(got[0].mark.del, None);
assert_eq!(rev(got[1].mark.del), Some((RevisionKind::Delete, "Bob", "2026-05-02T10:00:00Z")));
assert_eq!(got[1].mark.bold, Some(true));
assert_eq!(got[1].mark.ins, None);
assert_eq!((got[2].mark.ins, got[2].mark.del), (None, None));
assert_eq!(got.iter().map(|p| p.text.as_str()).collect::<Vec<_>>(), ["Owned ALPHA ", "Owned BETA", "plain"]);
}
#[test]
fn fields_and_special_chars_round_trip() {
let mut p = Paragraph::with_text("a\tb\nc\u{000C}d\u{000E}e\u{2011}f\u{00AD}g spaced ", CharProps::default());
let fields = [
InlineObject::Field { instr: "PAGE".into(), result: "4".into(), locked: false, dirty: false, code: false, form: String::new() },
InlineObject::Field {
instr: "DATE \\@ \"M/d/yyyy\"".into(),
result: "1/2/2026".into(),
locked: true,
dirty: false,
code: false,
form: String::new(),
},
InlineObject::Field { instr: "NUMPAGES".into(), result: String::new(), locked: false, dirty: false, code: false, form: String::new() },
];
for f in &fields {
let end = p.len();
p.insert_object(end, f.clone(), &CharProps { bold: Some(true), ..Default::default() }).unwrap();
}
let r = rt(&doc_with(vec![p.clone()]));
let got = paras(&r)[0];
assert_eq!(got.text, p.text);
assert_eq!(got.objects, p.objects);
assert_eq!(got.runs, p.runs);
}
/// The `document.xml` of a written package.
fn document_xml(bytes: &[u8]) -> String {
let mut zip = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap()
}
/// #877: a field begin marker's `w:dirty` (the cached result is stale; Word refreshes it on
/// open) survives a round trip, and a field without the flag doesn't gain one. Generators that
/// can't paginate (pandoc-style pipelines, python-docx templates) set the flag instead of a result.
#[test]
fn field_dirty_flag_round_trips() {
let mut p = Paragraph::with_text("", CharProps::default());
for instr in ["PAGE", "DATE"] {
let end = p.len();
p.insert_object(
end,
InlineObject::Field { instr: instr.into(), result: "7".into(), locked: false, dirty: false, code: false, form: String::new() },
&CharProps::default(),
)
.unwrap();
}
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
// Another producer marks the first field's begin as dirty.
let xml = document_xml(&bytes);
let marked = xml.replacen(r#"<w:fldChar w:fldCharType="begin"/>"#, r#"<w:fldChar w:fldCharType="begin" w:dirty="true"/>"#, 1);
assert_ne!(&marked, &xml, "the written begin marker must be bare: {xml}");
let r = wordcraft_docx::read(&replace_part(&bytes, "word/document.xml", marked.as_bytes())).expect("read");
let out = document_xml(&wordcraft_docx::write(&r).expect("write"));
assert_eq!(out.matches("w:dirty").count(), 1, "the dirty field keeps its flag, the other gains none: {out}");
assert!(out.contains(r#"<w:fldChar w:fldCharType="begin" w:dirty="true"/>"#), "{out}");
}
/// #877: a TOC imported as a range field keeps `w:dirty` through a round trip — the flag sits on
/// the begin marker Word rebuilds the field from (#878's fixture shape: a placeholder result).
#[test]
fn range_toc_dirty_flag_round_trips() {
let mut toc = Paragraph::new();
toc.insert_object(0, InlineObject::FieldStart { instr: r#"TOC \o "1-3" \h \z \u"#.into(), locked: false, dirty: false }, &CharProps::default())
.unwrap();
let end = toc.len();
toc.insert_text(end, "Placeholder: update fields (F9).", &CharProps::default()).unwrap();
let end = toc.len();
toc.insert_object(end, InlineObject::FieldEnd, &CharProps::default()).unwrap();
let mut blocks = vec![toc];
for (t, style) in [("Alpha", Some("Heading1")), ("Body text.", None), ("Beta", Some("Heading2")), ("Gamma", Some("Heading1"))] {
let mut h = Paragraph::with_text(t, CharProps::default());
h.props.style = style.map(str::to_string);
blocks.push(h);
}
let bytes = wordcraft_docx::write(&doc_with(blocks)).expect("write");
let xml = document_xml(&bytes);
let marked = xml.replacen(r#"<w:fldChar w:fldCharType="begin"/>"#, r#"<w:fldChar w:fldCharType="begin" w:dirty="true"/>"#, 1);
assert_ne!(&marked, &xml, "the written begin marker must be bare: {xml}");
let marked = replace_part(&bytes, "word/document.xml", marked.as_bytes());
let r = wordcraft_docx::read(&marked).expect("read");
// Still the imported shape: a range field holding the placeholder as ordinary content.
assert!(matches!(paras(&r)[0].objects.first(), Some(InlineObject::FieldStart { .. })), "{:?}", paras(&r)[0].objects);
assert!(paras(&r)[0].objects.last().is_some_and(|o| matches!(o, InlineObject::FieldEnd)));
assert_eq!(paras(&r)[0].plain_text(), "Placeholder: update fields (F9).");
let out = document_xml(&wordcraft_docx::write(&r).expect("write"));
assert_eq!(out.matches("w:dirty").count(), 1, "the TOC keeps its flag: {out}");
let (begin, placeholder) = (out.find("fldCharType=\"begin\"").unwrap(), out.find("Placeholder").unwrap());
let (separate, end) = (out.find("fldCharType=\"separate\"").unwrap(), out.find("fldCharType=\"end\"").unwrap());
assert!(begin < separate && separate < placeholder && placeholder < end, "the placeholder stays the field's result: {out}");
}
#[test]
fn shapes_textboxes_equations_dropcaps_round_trip() {
let mut d = Document::new();
let story =
d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Inside the box", CharProps { bold: Some(true), ..Default::default() }))]);
let tb = InlineObject::Shape {
kind: ShapeKind::TextBox,
w: 144.0,
h: 72.0,
fill: Some(Fill::solid(Rgb(255, 255, 200))),
stroke: Some(Rgb(0, 0, 0)),
stroke_width: 1.0,
float: Float { wrap: Wrap::Square, h_rel: Anchor::Margin, v_rel: Anchor::Paragraph, x: 10.0, y: 20.0, dist: 0.0, ..Default::default() },
story: Some(story),
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
let star = InlineObject::Shape {
kind: ShapeKind::Star,
w: 20.0,
h: 20.0,
fill: None,
stroke: None,
stroke_width: 0.0,
float: Float::default(),
story: None,
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
let eq = InlineObject::Equation { linear: "x=(-b±√(b^2-4ac))/2a".into(), display: false, math: Default::default() };
let mut p = Paragraph::with_text("shapes ", CharProps::default());
for o in [tb, star.clone(), eq.clone()] {
let end = p.len();
p.insert_object(end, o, &CharProps::default()).unwrap();
}
let mut dc = Paragraph::with_text("Once upon a time", CharProps::default());
dc.props.drop_cap = Some(3);
dc.props.space_after = Some(4.0);
d.body = vec![para_block(p.clone()), para_block(dc.clone())];
let r = rt(&d);
let got = paras(&r);
assert_eq!(got[0].objects.len(), 3);
match &got[0].objects[0] {
InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, story, .. } => {
assert_eq!(
(*kind, *w, *h, fill.clone(), *stroke, *stroke_width),
(ShapeKind::TextBox, 144.0, 72.0, Some(Fill::solid(Rgb(255, 255, 200))), Some(Rgb(0, 0, 0)), 1.0)
);
assert_eq!(float.wrap, Wrap::Square);
assert_eq!(part_text(&r, *story), "Inside the box");
}
o => panic!("{o:?}"),
}
assert_eq!(got[0].objects[1], star);
match &got[0].objects[2] {
InlineObject::Equation { linear, display, math } => {
assert_eq!(linear, "x=(-b±√(b^2-4ac))/2a");
assert!(!display);
assert_eq!(math.nodes, wordcraft_doc::math::parse_linear(linear), "structure is written as OMML and read back");
}
o => panic!("{o:?}"),
}
assert_eq!(got.len(), 2, "drop cap paragraph merges back");
assert_eq!(got[1].text, dc.text);
assert_eq!(got[1].props, dc.props);
}
/// A group of a picture, a shape and a text box (`wpg:wgp`) comes back as it was saved: its
/// size, placement and members' space, and each member's offset, size and content.
#[test]
fn groups_round_trip() {
use wordcraft_doc::para::GroupChild;
let mut d = Document::new();
let key = d.add_media(tiny_png(), "png");
let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("In the group", CharProps::default()))]);
let pic = InlineObject::Image {
media: key,
w: 60.0,
h: 40.0,
alt: "A picture".into(),
float: Float::default(),
crop: [0.0; 4],
fx: Default::default(),
ole: None,
};
let oval = InlineObject::Shape {
kind: ShapeKind::Ellipse,
w: 50.0,
h: 30.0,
fill: Some(Fill::solid(Rgb(200, 0, 0))),
stroke: None,
stroke_width: 0.0,
float: Float::default(),
story: None,
freeform: None,
// A member's shape effects (#275) come back too.
effects: wordcraft_doc::effects::ShapeEffects {
shadow: Some(wordcraft_doc::effects::Shadow {
color: Rgb(0x20, 0x30, 0x40),
transparency: 60.0,
blur: 4.0,
distance: 3.0,
angle: 135.0,
rot_with_shape: false,
}),
glow: None,
soft_edge: Some(2.5),
},
extra: Default::default(),
};
let tb = InlineObject::Shape {
kind: ShapeKind::TextBox,
w: 100.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(255, 255, 255))),
stroke: Some(Rgb(0, 0, 0)),
stroke_width: 0.75,
float: Float::default(),
story: Some(story),
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
let float = Float { wrap: Wrap::Square, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 20.0, y: 10.0, dist: 9.0, ..Default::default() };
let group = InlineObject::Group {
w: 240.0,
h: 120.0,
float: float.clone(),
ch_w: 200.0,
ch_h: 100.0,
children: vec![
GroupChild { x: 0.0, y: 0.0, obj: pic },
GroupChild { x: 150.0, y: 10.0, obj: oval.clone() },
GroupChild { x: 50.0, y: 60.0, obj: tb },
],
canvas: None,
};
let mut p = Paragraph::with_text("grouped ", CharProps::default());
let end = p.len();
p.insert_object(end, group, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
let r = unstacked(rt(&d));
let got = paras(&r);
let InlineObject::Group { w, h, float: f, ch_w, ch_h, children, .. } = &got[0].objects[0] else { panic!("{:?}", got[0].objects) };
assert_eq!((*w, *h, *ch_w, *ch_h), (240.0, 120.0, 200.0, 100.0));
assert_eq!(*f, float);
assert_eq!(children.iter().map(|c| (c.x, c.y)).collect::<Vec<_>>(), [(0.0, 0.0), (150.0, 10.0), (50.0, 60.0)]);
match &children[0].obj {
InlineObject::Image { media, w, h, alt, .. } => {
assert_eq!((*w, *h, alt.as_str()), (60.0, 40.0, "A picture"));
assert_eq!(r.media.get(media).map(|m| m.as_slice()), Some(tiny_png().as_slice()));
}
o => panic!("{o:?}"),
}
assert_eq!(children[1].obj, oval);
match &children[2].obj {
InlineObject::Shape { kind, w, h, story, .. } => {
assert_eq!((*kind, *w, *h), (ShapeKind::TextBox, 100.0, 40.0));
assert_eq!(part_text(&r, *story), "In the group");
}
o => panic!("{o:?}"),
}
}
/// A Drawing Canvas (`wpc:wpc`, #344) with a picture and a shape comes back as a canvas: its
/// frame, background and outline, and each member at its offset in the canvas, unscaled.
#[test]
fn drawing_canvas_round_trips() {
use wordcraft_doc::para::{CanvasStyle, GroupChild};
let mut d = Document::new();
let key = d.add_media(tiny_png(), "png");
let pic = InlineObject::Image {
media: key,
w: 60.0,
h: 40.0,
alt: "In the canvas".into(),
float: Float::default(),
crop: [0.0; 4],
fx: Default::default(),
ole: None,
};
let star = InlineObject::Shape {
kind: ShapeKind::Star,
w: 72.0,
h: 72.0,
fill: Some(Fill::solid(Rgb(0xE0, 0xA0, 0x20))),
stroke: Some(Rgb(0x40, 0x40, 0x40)),
stroke_width: 1.0,
float: Float::default(),
story: None,
effects: Default::default(),
freeform: None,
extra: Default::default(),
};
let style = CanvasStyle {
fill: Some(Fill::Solid { color: Rgb(0xF0, 0xF4, 0xFF), transparency: 25.0 }),
stroke: Some(Rgb(0x20, 0x40, 0x80)),
stroke_width: 1.5,
};
let canvas = InlineObject::Group {
w: 432.0,
h: 216.0,
float: Float::default(),
ch_w: 432.0,
ch_h: 216.0,
children: vec![GroupChild { x: 12.0, y: 18.0, obj: pic }, GroupChild { x: 300.0, y: 100.0, obj: star.clone() }],
canvas: Some(style.clone()),
};
let mut p = Paragraph::with_text("drawn ", CharProps::default());
let end = p.len();
p.insert_object(end, canvas, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
let bytes = wordcraft_docx::write(&d).unwrap();
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains("wordprocessingCanvas") && xml.contains("<wpc:wpc>") && xml.contains("<wpc:bg>") && xml.contains("<wpc:whole>"), "{xml}");
let r = wordcraft_docx::read(&bytes).unwrap();
let got = paras(&r);
let InlineObject::Group { w, h, ch_w, ch_h, children, canvas, .. } = &got[0].objects[0] else { panic!("{:?}", got[0].objects) };
assert_eq!((*w, *h, *ch_w, *ch_h), (432.0, 216.0, 432.0, 216.0));
assert_eq!(*canvas, Some(style));
assert_eq!(children.iter().map(|c| (c.x, c.y)).collect::<Vec<_>>(), [(12.0, 18.0), (300.0, 100.0)]);
assert!(matches!(&children[0].obj, InlineObject::Image { w, h, alt, .. } if (*w, *h, alt.as_str()) == (60.0, 40.0, "In the canvas")));
assert_eq!(children[1].obj, star);
}
/// A turned and flipped Drawing Canvas (#344 with #332): the canvas schema has no transform, so
/// its turn rides in our `wpc:extLst` extension, after its members; members keep their own turn.
/// An unturned canvas writes no extension.
#[test]
fn rotated_drawing_canvas_round_trips() {
use wordcraft_doc::para::{CanvasStyle, GroupChild};
let member = InlineObject::Shape {
kind: ShapeKind::Rectangle,
w: 60.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(1, 2, 3))),
stroke: None,
stroke_width: 0.0,
float: Float { rot: 15.0, ..Default::default() },
story: None,
effects: Default::default(),
freeform: None,
extra: Default::default(),
};
let canvas = |float: Float| InlineObject::Group {
w: 200.0,
h: 100.0,
float,
ch_w: 200.0,
ch_h: 100.0,
children: vec![GroupChild { x: 10.0, y: 20.0, obj: member.clone() }],
canvas: Some(CanvasStyle { fill: Some(Fill::solid(Rgb(0xF0, 0xF4, 0xFF))), stroke: None, stroke_width: 0.0 }),
};
let square = Float { wrap: Wrap::Square, ..Default::default() };
let mut p = Paragraph::with_text("c", CharProps::default());
p.insert_object(1, canvas(Float { rot: 30.0, flip_h: true, ..square.clone() }), &CharProps::default()).unwrap();
let end = p.len();
p.insert_object(end, canvas(square), &CharProps::default()).unwrap();
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(
xml.contains(r#"<wpc:extLst><a:ext uri="urn:wordcraft:canvas-xfrm"><a:xfrm rot="1800000" flipH="1"/></a:ext></wpc:extLst></wpc:wpc>"#),
"{xml}"
);
assert_eq!(xml.matches("<wpc:extLst>").count(), 1, "{xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let got = ¶s(&r)[0].objects;
let spins: Vec<(f32, bool, bool)> = got.iter().map(|o| o.frame().unwrap().2).map(|f| (f.rot, f.flip_h, f.flip_v)).collect();
assert_eq!(spins, [(30.0, true, false), (0.0, false, false)]);
let InlineObject::Group { children, canvas, .. } = &got[0] else { panic!("{got:?}") };
assert!(canvas.is_some());
assert_eq!(children.len(), 1);
assert_eq!(children[0].obj.frame().unwrap().2.rot, 15.0);
}
#[test]
fn table_contextual_spacing_compatibility_flag_round_trips() {
for mode in [11, 12, 14, 15] {
for allow in [false, true] {
let mut d = Document::new();
d.settings.compat_mode = mode;
d.settings.allow_space_of_same_style_in_table = allow;
let r = rt(&d);
assert_eq!(r.settings.allow_space_of_same_style_in_table, allow);
assert_eq!(r.settings.compat_mode, mode);
if allow {
let bytes = wordcraft_docx::write(&d).unwrap();
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/settings.xml", 16 << 20).unwrap().unwrap()).unwrap();
// CT_Compat requires the boolean option before compatSetting.
assert!(xml.find("<w:allowSpaceOfSameStyleInTable").unwrap() < xml.find("<w:compatSetting").unwrap());
}
}
}
}
#[test]
fn compatibility_mode_round_trips() {
// New documents are Word 2013+ documents; an older file keeps its mode, so saving it doesn't
// change how Word lays it out.
assert_eq!(rt(&Document::new()).settings.compat_mode, wordcraft_doc::COMPAT_MODE_CURRENT);
for mode in [11, 12, 14, 15] {
let mut d = Document::new();
d.settings.compat_mode = mode;
assert_eq!(rt(&d).settings.compat_mode, mode);
}
}
/// Tools › Templates and Add-ins: the attached template (an external relationship of the settings
/// part) and "Automatically update document styles" (`w:linkStyles`) round-trip, written in the
/// schema's order (after `w:mirrorMargins`, before `w:trackRevisions`).
#[test]
fn attached_template_and_link_styles_round_trip() {
let mut d = Document::new();
d.settings.attached_template = Some("file:///C:/Templates/Report & Co.dotx".into());
d.settings.link_styles = true;
d.settings.mirror_margins = true;
d.settings.track_changes = true;
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/settings.xml", 16 << 20).unwrap().unwrap()).unwrap();
let at = |tag: &str| xml.find(tag).unwrap_or_else(|| panic!("{tag} missing: {xml}"));
assert!(at("<w:mirrorMargins") < at("<w:attachedTemplate"));
assert!(at("<w:attachedTemplate") < at("<w:linkStyles"));
assert!(at("<w:linkStyles") < at("<w:trackRevisions"));
let rels = String::from_utf8(zip.read("word/_rels/settings.xml.rels", 16 << 20).unwrap().unwrap()).unwrap();
assert!(rels.contains("relationships/attachedTemplate") && rels.contains("TargetMode=\"External\""), "{rels}");
let r = wordcraft_docx::read(&bytes).expect("read");
assert_eq!(r.settings.attached_template.as_deref(), Some("file:///C:/Templates/Report & Co.dotx"));
assert!(r.settings.link_styles);
// Detached: neither element nor relationship is written.
let plain = rt(&Document::new());
assert_eq!(plain.settings.attached_template, None);
assert!(!plain.settings.link_styles);
}
/// Gutter position Top (`w:gutterAtTop`) is kept when a document is opened and saved again, and
/// is not written when it is off.
#[test]
fn gutter_at_top_survives_open_and_save() {
let settings_xml = |bytes: &[u8]| {
let mut zip = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
String::from_utf8(zip.read("word/settings.xml", 16 << 20).unwrap().unwrap()).unwrap()
};
let mut d = Document::new();
d.settings.gutter_at_top = true;
let first = wordcraft_docx::write(&d).expect("write");
assert_eq!(settings_xml(&first).matches("<w:gutterAtTop/>").count(), 1);
let opened = wordcraft_docx::read(&first).expect("read");
assert!(opened.settings.gutter_at_top);
let saved = wordcraft_docx::write(&opened).expect("write again");
assert_eq!(settings_xml(&saved).matches("<w:gutterAtTop/>").count(), 1);
assert!(wordcraft_docx::read(&saved).expect("read again").settings.gutter_at_top);
let plain = wordcraft_docx::write(&Document::new()).expect("write plain");
assert!(!settings_xml(&plain).contains("gutterAtTop"));
}
/// #995: the zoom a document was saved at (`w:zoom`), One Page (`fullPage`) included, is read
/// and written back.
#[test]
fn zoom_round_trips() {
let settings = |bytes: &[u8]| {
let mut zip = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
String::from_utf8(zip.read("word/settings.xml", 16 << 20).unwrap().unwrap()).unwrap()
};
let plain = wordcraft_docx::write(&Document::new()).unwrap();
let xml = settings(&plain);
assert!(xml.contains(r#"<w:zoom w:percent="100"/>"#), "{xml}");
for (zoom, written) in [
(r#"<w:zoom w:val="fullPage" w:percent="62"/>"#, r#"<w:zoom w:val="fullPage" w:percent="62"/>"#),
(r#"<w:zoom w:percent="75%"/>"#, r#"<w:zoom w:percent="75"/>"#),
(r#"<w:zoom w:val="bestFit" w:percent="99999"/>"#, r#"<w:zoom w:val="bestFit" w:percent="500"/>"#),
(r#"<w:zoom w:val="sideways" w:percent="80"/>"#, r#"<w:zoom w:percent="80"/>"#),
] {
let file = replace_part(&plain, "word/settings.xml", xml.replace(r#"<w:zoom w:percent="100"/>"#, zoom).as_bytes());
let back = settings(&wordcraft_docx::write(&wordcraft_docx::read(&file).unwrap()).unwrap());
assert!(back.contains(written), "{zoom}: {back}");
}
}
#[test]
fn settings_core_theme_round_trip() {
let mut d = Document::new();
d.settings.track_changes = true;
d.settings.default_tab = 18.0;
d.settings.even_odd_headers = true;
d.settings.mirror_margins = true;
d.settings.auto_hyphenation = true;
// Hyphenation Options (#407): zone, words in capitals, consecutive hyphens.
d.settings.hyphenation_zone = 27.0;
d.settings.hyphenate_caps = false;
d.settings.consecutive_hyphen_limit = 2;
d.settings.page_color = Some(Rgb(250, 240, 230));
d.settings.major_font = "Cambria".into();
d.settings.minor_font = "Calibri".into();
d.settings.theme_colors[4] = Rgb(1, 2, 3);
d.settings.theme_name = "Mine".into();
d.settings.protection = Some("readOnly".into());
d.settings.grid_h = 5.5;
d.settings.grid_v = 18.0;
d.settings.math = Some(wordcraft_doc::math::MathProps {
brk_bin: wordcraft_doc::math::BrkBin::Repeat,
brk_bin_sub: wordcraft_doc::math::BrkBinSub::PlusMinus,
wrap_indent: 36.0,
wrap_right: false,
});
d.core.title = "Title & <stuff>".into();
d.core.subject = "Subj".into();
d.core.creator = "Me".into();
d.core.keywords = "a, b".into();
d.core.description = "Desc".into();
d.core.category = "Cat".into();
d.core.last_modified_by = "You".into();
d.core.created = "2026-01-01T00:00:00Z".into();
d.core.modified = "2026-02-01T00:00:00Z".into();
d.core.revision = 7;
let r = rt(&d);
assert_eq!(r.settings, d.settings);
assert_eq!(r.core, d.core);
// #1290: the watermark is written as a VML text shape in the headers and read back.
let mut w = d.clone();
w.settings.watermark = Some(Watermark::default());
assert_eq!(rt(&w).settings.watermark, w.settings.watermark);
}
fn part_xml(bytes: &[u8], name: &str) -> String {
let mut z = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
String::from_utf8(z.read(name, 16 << 20).unwrap().unwrap()).unwrap()
}
/// Header parts in the document, by id.
fn header_ids(doc: &Document) -> Vec<u32> {
doc.parts.iter().filter(|(_, p)| p.kind == PartKind::Header).map(|(id, _)| *id).collect()
}
/// #1290: a watermark round-trips through Word's VML text shape: text, font, colour, diagonal and
/// semitransparent, defaults or not.
#[test]
fn watermark_roundtrips() {
for wm in [
Watermark::default(),
Watermark {
text: "Riservato & <interno>".into(),
font: "Georgia".into(),
color: Rgb(0x80, 0x10, 0x20),
diagonal: false,
semitransparent: false,
size: None,
},
// A box of its own (not Word's default for the page) is kept.
Watermark { text: "COPY".into(), size: Some([300.0, 80.0]), ..Default::default() },
] {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
d.settings.watermark = Some(wm.clone());
let r = rt(&d);
assert_eq!(r.settings.watermark, Some(wm));
assert_eq!(paras(&r).len(), 1, "the body gains nothing");
}
}
/// #3994: a watermark font name round-trips through the textpath's CSS-like style whatever it
/// carries — apostrophes, semicolons, colons, quotes, backslashes. Before, those characters
/// were deleted (the font was saved under a different name) and a trailing backslash escaped
/// the style's closing quote.
#[test]
fn watermark_font_roundtrips_through_the_textpath_style() {
for font in ["Georgia", "Bob's Serif", "A;Named:Font", "Quote\"Inside", "Ends with \\", "All \"of\" ;it: 'here\\", "'Serif'", "Trailing'"] {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
d.settings.watermark = Some(Watermark { font: font.into(), ..Default::default() });
assert_eq!(rt(&d).settings.watermark.map(|w| w.font), Some(font.into()), "{font:?}");
}
}
/// #3994: the written textpath style stays well-formed CSS whatever the font name: control
/// characters are dropped (no font name carries one) and a backslash or quote is a CSS escape
/// (`\5c `, `\22 `) instead of escaping the string's closing quote.
#[test]
fn watermark_font_name_writes_wellformed_css() {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
d.settings.watermark = Some(Watermark { font: "Ends with \\ and \n\"quoted\"".into(), ..Default::default() });
let bytes = wordcraft_docx::write(&d).unwrap();
let hdr = part_xml(&bytes, "word/header1.xml");
let style = hdr.split("v:textpath style=\"").nth(1).and_then(|s| s.split('"').next()).unwrap_or_default();
assert!(!style.contains('\n'), "control characters are dropped: {style}");
assert!(style.contains(r#"font-family:"Ends with \5c and \22 quoted\22 ";"#), "CSS escapes: {style}");
}
/// #1290: a document without headers gains one default header holding only the watermark (an
/// empty paragraph once read back); saving again neither adds another nor duplicates the shape.
#[test]
fn watermark_without_header_gains_one() {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
d.settings.watermark = Some(Watermark::default());
let bytes = wordcraft_docx::write(&d).unwrap();
let hdr = part_xml(&bytes, "word/header1.xml");
assert_eq!(hdr.matches("<v:shape ").count(), 1);
assert!(hdr.contains(r#"id="PowerPlusWaterMarkObject1""#) && hdr.contains("rotation:315") && hdr.contains(r#"<v:fill opacity=".5"/>"#));
// The text sits between the top and bottom edges: on one line Word gives it no height.
assert!(hdr.contains(r#"path="m0,0l21600,0m0,21600l21600,21600e""#));
assert!(part_xml(&bytes, "word/document.xml").contains(r#"<w:headerReference w:type="default""#));
let r = wordcraft_docx::read(&bytes).unwrap();
assert_eq!(r.settings.watermark, d.settings.watermark);
let ids = header_ids(&r);
assert_eq!(ids.len(), 1);
assert_eq!(r.last_section.headers.default, ids.first().copied());
let blocks = &r.parts[&ids[0]].blocks;
assert_eq!(blocks.len(), 1);
let p = blocks[0].as_para().unwrap();
assert!(p.text.is_empty() && p.objects.is_empty(), "the shape leaves nothing behind: {p:?}");
// Second generation: stable.
let r2 = rt(&r);
assert_eq!(r2.settings.watermark, d.settings.watermark);
assert_eq!(header_ids(&r2).len(), 1);
assert_eq!(r2.parts[&header_ids(&r2)[0]].blocks.len(), 1);
}
/// #1290: a header keeps its own text, and the watermark goes into its first paragraph (no extra
/// line). Each header part carries the shape; footers don't.
#[test]
fn watermark_joins_existing_headers() {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
let h = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Head", CharProps::default()))]);
let hf = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("First", CharProps::default()))]);
let f = d.add_part(PartKind::Footer, vec![para_block(Paragraph::with_text("Foot", CharProps::default()))]);
d.last_section.headers.default = Some(h);
d.last_section.headers.first = Some(hf);
d.last_section.title_page = true;
d.last_section.footers.default = Some(f);
d.settings.watermark = Some(Watermark::default());
let bytes = wordcraft_docx::write(&d).unwrap();
for name in ["word/header1.xml", "word/header2.xml"] {
assert_eq!(part_xml(&bytes, name).matches("<v:shape ").count(), 1, "{name}");
}
assert!(!part_xml(&bytes, "word/footer1.xml").contains("v:shape"));
let r = wordcraft_docx::read(&bytes).unwrap();
assert_eq!(r.settings.watermark, d.settings.watermark);
assert_eq!(header_ids(&r).len(), 2, "no header was added");
assert_eq!(part_text(&r, r.last_section.headers.default), "Head");
assert_eq!(part_text(&r, r.last_section.headers.first), "First");
for id in header_ids(&r) {
assert_eq!(r.parts[&id].blocks.len(), 1);
}
}
/// #1290: only the slots the pages show and nothing fills get the watermark's own header: a
/// later section still links to the earlier one's header, and a title page with no first-page
/// header gets one.
#[test]
fn watermark_header_respects_linking() {
let mut d = Document::new();
let h = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Head", CharProps::default()))]);
let mut s1 = SectionProps::default();
s1.headers.default = Some(h);
s1.title_page = true;
let mut p1 = Paragraph::with_text("One", CharProps::default());
p1.section = Some(Box::new(s1));
d.body = vec![para_block(p1), para_block(Paragraph::with_text("Two", CharProps::default()))];
d.last_section.title_page = true;
d.settings.watermark = Some(Watermark::default());
let r = rt(&d);
assert_eq!(r.settings.watermark, d.settings.watermark);
let secs = r.sections();
assert_eq!(part_text(&r, secs[0].1.headers.default), "Head");
let first = secs[0].1.headers.first.expect("a first-page header for the watermark");
assert_eq!(part_text(&r, Some(first)), "");
assert_eq!(secs[1].1.headers, Default::default(), "the second section still links to the first");
assert_eq!(header_ids(&r).len(), 2);
}
/// #1290: a header holding only a table takes the watermark in the paragraph after the table
/// (one every story ends with), so it gains no line.
#[test]
fn watermark_in_table_only_header() {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
let t = Table::new(1, 2, 400.0);
let h = d.add_part(PartKind::Header, vec![Arc::new(Block::Table(t))]);
d.last_section.headers.default = Some(h);
let blocks = |d: &Document| d.parts[&d.last_section.headers.default.unwrap()].blocks.len();
let plain = blocks(&rt(&d));
d.settings.watermark = Some(Watermark::default());
let r = rt(&d);
assert_eq!(r.settings.watermark, d.settings.watermark);
assert_eq!(blocks(&r), plain);
}
/// #1290: with different odd and even pages, a document with only a default header gains an
/// even-page header for the watermark; a later section stays linked to both.
#[test]
fn watermark_even_pages_header() {
let mut d = Document::new();
let h = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Head", CharProps::default()))]);
let mut s1 = SectionProps::default();
s1.headers.default = Some(h);
let mut p1 = Paragraph::with_text("One", CharProps::default());
p1.section = Some(Box::new(s1));
d.body = vec![para_block(p1), para_block(Paragraph::with_text("Two", CharProps::default()))];
d.settings.even_odd_headers = true;
d.settings.watermark = Some(Watermark::default());
let r = rt(&d);
assert_eq!(r.settings.watermark, d.settings.watermark);
let secs = r.sections();
assert_eq!(part_text(&r, secs[0].1.headers.default), "Head");
assert!(secs[0].1.headers.even.is_some() && secs[0].1.headers.first.is_none());
assert_eq!(secs[1].1.headers, Default::default());
}
/// #1290: a blank watermark isn't written (it wouldn't read back), and adds no header.
#[test]
fn blank_watermark_writes_nothing() {
let mut d = doc_with(vec![Paragraph::with_text("Body", CharProps::default())]);
d.settings.watermark = Some(Watermark { text: " ".into(), ..Watermark::default() });
let r = rt(&d);
assert_eq!(r.settings.watermark, None);
assert!(header_ids(&r).is_empty());
}
/// A document that uses everything, for second-generation stability checks.
fn kitchen_sink() -> Document {
let mut d = Document::new();
let png = tiny_png();
let key = d.add_media(png, "png");
let num = Arc::make_mut(&mut d.numbering).add_list(ListKind::Numbered);
let h = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Head", CharProps::default()))]);
let f = d.add_part(PartKind::Footnote, vec![para_block(Paragraph::with_text("Note", CharProps::default()))]);
let c = d.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text("Comment", CharProps::default()))]);
d.comments.insert(3, Comment { author: "X".into(), part: c, ..Default::default() });
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "A".into(), date: String::new(), move_name: None });
d.last_section.headers.default = Some(h);
let mut blocks: Blocks = Vec::new();
let mut p = para_runs(&[
("Hello ", CharProps::default()),
("bold", CharProps { bold: Some(true), ..Default::default() }),
(" link", CharProps { link: Some("https://x.org".into()), ..Default::default() }),
]);
p.insert_object(0, InlineObject::CommentStart { id: 3 }, &CharProps::default()).unwrap();
let end = p.len();
p.insert_object(end, InlineObject::CommentEnd { id: 3 }, &CharProps::default()).unwrap();
let at = p.text.find("bold").unwrap();
p.insert_object(at, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
blocks.push(para_block(p));
let mut li = Paragraph::with_text("listed", CharProps { ins: Some(0), ..Default::default() });
li.props.numbering = Some(NumRef { num, level: 0 });
blocks.push(para_block(li));
let mut img = Paragraph::new();
img.insert_object(
0,
InlineObject::Image {
media: key,
w: 30.0,
h: 20.0,
alt: "pic".into(),
float: Float::default(),
crop: [0.0; 4],
fx: Default::default(),
ole: None,
},
&CharProps::default(),
)
.unwrap();
blocks.push(para_block(img));
let mut t = Table::new(2, 2, 300.0);
t.merge(0, 1, 1, 1);
t.rows[0].cells[0] = Cell::with_text("cell");
blocks.push(Arc::new(Block::Table(t)));
blocks.push(para_block(Paragraph::new()));
d.body = blocks;
d.sources.push(Source {
tag: "Sink2026".into(),
kind: "book".into(),
author: "Author, First".into(),
title: "Title".into(),
year: "2026".into(),
editor: "Editor, Chief".into(),
edition: "3rd".into(),
issue: "2".into(),
month: "08".into(),
day: "24".into(),
accessed: "2026-08-25".into(),
doi: "10.1234/sink.2026".into(),
..Default::default()
});
d
}
#[test]
fn second_generation_is_stable() {
let d1 = rt(&kitchen_sink());
let d2 = rt(&d1);
assert_eq!(d2.body, d1.body);
assert_eq!(d2.parts, d1.parts);
assert_eq!(d2.styles, d1.styles);
assert_eq!(d2.numbering, d1.numbering);
assert_eq!(d2.comments, d1.comments);
assert_eq!(d2.revisions, d1.revisions);
assert_eq!(d2.settings, d1.settings);
assert_eq!(d2.media, d1.media);
assert_eq!(d2.sources, d1.sources);
assert_eq!(d2, d1);
}
/// A Word XML Document (Flat OPC) carries the same package as a .docx: reading it back gives
/// what the .docx round trip gives, pictures included (#548).
#[test]
fn flat_opc_round_trip_equals_docx() {
let d = kitchen_sink();
let xml = wordcraft_docx::write_flat(&d).expect("write flat");
let text = std::str::from_utf8(&xml).expect("utf-8");
assert!(text.starts_with("<?xml") && text.contains("<?mso-application progid=\"Word.Document\"?>"));
assert!(text.contains("pkg:name=\"/word/document.xml\"") && text.contains("<pkg:binaryData>"));
assert_eq!(wordcraft_docx::sniff_xml(&xml), wordcraft_docx::XmlKind::FlatOpc);
let mut back = wordcraft_docx::read_xml(&xml).expect("read flat");
// `pkg:xmlData` inlines a part without its XML declaration, so a kept XML part (the font
// table) comes back without one; the markup is the same.
let mut want = rt(&d);
for doc in [&mut back, &mut want] {
for v in doc.passthrough.values_mut() {
if let Some(rest) =
v.strip_prefix(b"<?xml").and_then(|r| r.iter().position(|&b| b == b'>').map(|e| r[e + 1..].trim_ascii_start().to_vec()))
{
*v = Arc::new(rest);
}
}
}
assert!(back.passthrough.contains_key("word/fontTable.xml"));
assert_eq!(back, want);
assert_eq!(back.media.len(), 1);
}
#[test]
fn builtin_stylesheet_survives() {
let d = Document::new();
let r = rt(&d);
assert_eq!(r.styles, d.styles);
assert_eq!(r.body, d.body);
assert_eq!(r.last_section, d.last_section);
}
#[test]
fn hostile_model_values_still_write() {
let mut d = Document::new();
let mut p = Paragraph::with_text(
"x\u{1}\u{FFFE}y<&>\"'",
CharProps { size: Some(f32::NAN), spacing: Some(f32::INFINITY), font: Some("A\"B<".into()), ..Default::default() },
);
p.props.indent_left = Some(f32::NEG_INFINITY);
p.props.line_spacing = Some(LineSpacing::Multiple(f32::NAN));
p.insert_object(
0,
InlineObject::Opaque { format: "docx".into(), xml: "<w:r><w:t>raw</w:t></w:r>".into(), text: "raw".into() },
&CharProps::default(),
)
.unwrap();
p.insert_object(0, InlineObject::Opaque { format: "docx".into(), xml: "<broken".into(), text: "fallback".into() }, &CharProps::default())
.unwrap();
p.insert_object(
0,
InlineObject::Image {
media: "missing.png".into(),
w: -5.0,
h: f32::NAN,
alt: String::new(),
float: Float::default(),
crop: [f32::NAN; 4],
fx: Default::default(),
ole: None,
},
&CharProps::default(),
)
.unwrap();
p.insert_object(0, InlineObject::CommentEnd { id: 99 }, &CharProps::default()).unwrap();
p.insert_object(0, InlineObject::NoteRef { kind: NoteKind::Endnote, id: 12345, custom: String::new() }, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
d.media.insert("weird name/../x".into(), Arc::new(b"GIF89a....".to_vec()));
d.media.insert("".into(), Arc::new(vec![0, 1, 2]));
let bytes = wordcraft_docx::write(&d).unwrap();
let r = wordcraft_docx::read(&bytes).unwrap();
let t = paras(&r)[0].plain_text();
assert!(t.contains("y<&>\"'"), "{t}");
assert!(t.contains("raw") && t.contains("fallback"), "{t}");
// Media nothing references aren't written.
assert!(r.media.is_empty());
}
#[test]
fn ensure_empty_and_table_end_document_is_valid() {
let mut d = Document::new();
d.body = vec![Arc::new(Block::Table(Table::new(1, 1, 100.0)))];
let r = rt(&d);
assert!(matches!(*r.body[0], Block::Table(_)));
assert!(matches!(**r.body.last().unwrap(), Block::Para(_)));
let mut e = Document::new();
e.body.clear();
let r = rt(&e);
assert_eq!(r.body.len(), 1);
}
#[test]
fn self_showing_text_box_saves_bounded() {
// Crafted: a box whose 30 shapes all show that same box. Unbounded, saving would nest it.
let mut d = Document::from_text("Body");
let id = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Box", CharProps::default()))]);
let shape = || InlineObject::Shape {
kind: ShapeKind::TextBox,
w: 40.0,
h: 20.0,
fill: None,
stroke: None,
stroke_width: 0.0,
float: Float::default(),
story: Some(id),
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
for _ in 0..30 {
d.insert_object(
&wordcraft_doc::Pos { story: wordcraft_doc::StoryRef::Part(id), path: wordcraft_doc::Path::top(0), off: 0 },
shape(),
&CharProps::default(),
)
.unwrap();
}
d.insert_object(&wordcraft_doc::Pos::body(0, 0), shape(), &CharProps::default()).unwrap();
let bytes = wordcraft_docx::write(&d).unwrap();
assert!(bytes.len() < 200_000, "{} bytes", bytes.len());
// It still opens, with the box's text.
let back = wordcraft_docx::read(&bytes).unwrap();
assert!(back.parts.values().any(|p| p.kind == PartKind::TextBox));
}
#[test]
fn char_border_written_between_u_and_shd() {
let c =
CharProps { border: Some(Border::single(0.5)), underline: Some(Underline::Single), shading: Some(Rgb(0xFF, 0xFF, 0)), ..Default::default() };
let bytes = wordcraft_docx::write(&doc_with(vec![para_runs(&[("x", c)])])).unwrap();
let mut z = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(z.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
let bdr = r#"<w:bdr w:val="single" w:sz="4" w:space="0" w:color="auto"/>"#;
assert_eq!(xml.matches(bdr).count(), 1, "{xml}");
let at = xml.find(bdr).unwrap();
assert!(xml.find("<w:u ").unwrap() < at && at < xml.find("<w:shd ").unwrap(), "{xml}");
}
#[test]
fn floating_tables_round_trip() {
use wordcraft_doc::para::{Anchor, FloatAlign};
use wordcraft_doc::props::TableFloat;
let mut d = Document::new();
let mut t = Table::new(1, 2, 200.0);
let f = TableFloat {
h_rel: Anchor::Margin,
v_rel: Anchor::Paragraph,
x: 0.0,
y: -1.65,
h_align: None,
v_align: None,
dist: [9.0, 0.0, 12.0, 3.0],
overlap: false,
};
t.props.float = Some(f);
let mut page = Table::new(1, 1, 100.0);
let centred =
TableFloat { h_rel: Anchor::Page, v_rel: Anchor::Margin, h_align: Some(FloatAlign::Center), y: 36.0, overlap: true, ..Default::default() };
page.props.float = Some(centred);
d.body = vec![Arc::new(Block::Table(t)), Arc::new(Block::Table(page)), para_block(Paragraph::with_text("after", CharProps::default()))];
let back = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
let floats: Vec<_> = back.body.iter().filter_map(|b| if let Block::Table(t) = &**b { t.props.float } else { None }).collect();
assert_eq!(floats, [f, centred]);
}
#[test]
fn list_level_overrides_round_trip() {
use wordcraft_doc::numbering::{Counters, Level};
use wordcraft_doc::section::NumFormat;
let mut d = Document::new();
let num = Arc::make_mut(&mut d.numbering).add_list(ListKind::Numbered);
let restart = Arc::make_mut(&mut d.numbering).restart(num).unwrap();
let own = Level { format: NumFormat::DecimalZero, text: "%1.%2".into(), indent: 26.5, hanging: 26.5, ..Level::default() };
if let Some(n) = Arc::make_mut(&mut d.numbering).nums.iter_mut().find(|n| n.id == restart) {
n.level_overrides = vec![(1, own.clone())];
}
let back = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
let n = back.numbering.num(restart).unwrap();
assert_eq!(n.level_overrides.len(), 1);
let (lvl, got) = &n.level_overrides[0];
assert_eq!((*lvl, got.format, got.text.as_str(), got.indent, got.hanging), (1, NumFormat::DecimalZero, "%1.%2", 26.5, 26.5));
// The start overrides that `restart` wrote survive beside it.
assert_eq!(n.start_overrides, d.numbering.num(restart).unwrap().start_overrides);
let mut c = Counters::default();
assert_eq!(c.next_label(&back.numbering, restart, 0).unwrap().0, "1.");
assert_eq!(c.next_label(&back.numbering, restart, 1).unwrap().0, "1.01");
}
/// Ink strokes and freeform shapes are written as DrawingML custom geometry (`a:custGeom`,
/// `a:moveTo`/`a:lnTo`) in floating drawings and read back with their points, pen, opacity and
/// drawing order.
#[test]
fn ink_and_freeforms_round_trip_as_custom_geometry() {
use wordcraft_doc::freeform::{FreePath, Freeform, InkTool};
let shape = |fill: Option<Rgb>, stroke_width, wrap, f: Freeform| InlineObject::Shape {
kind: ShapeKind::Freeform,
w: f.w,
h: f.h,
fill: fill.map(Fill::solid),
stroke: Some(Rgb(0xC0, 0, 0)),
stroke_width,
float: Float { wrap, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 30.0, y: 12.0, ..Default::default() },
story: None,
freeform: Some(Arc::new(f)),
effects: Default::default(),
extra: Default::default(),
};
// The pen stroke was the seventh drawn: Ink Replay's order comes back too.
let pen = shape(
None,
2.0,
Wrap::InFrontOfText,
Freeform { order: Some(7), ..Freeform::ink(InkTool::Pen, 60.0, 20.0, vec![[1.0, 1.0], [30.0, 19.0], [59.0, 4.0]]) },
);
let marker = shape(None, 12.0, Wrap::BehindText, Freeform::ink(InkTool::Highlighter, 80.0, 12.0, vec![[6.0, 6.0], [74.0, 6.0]]));
let triangle = Freeform {
w: 40.0,
h: 40.0,
paths: vec![FreePath { pts: vec![[0.0, 40.0], [20.0, 0.0], [40.0, 40.0]], closed: true }],
..Default::default()
};
let tri = shape(Some(Rgb(0, 0x80, 0)), 1.0, Wrap::Square, triangle);
let mut p = Paragraph::with_text("Inked", CharProps::default());
for o in [pen.clone(), marker, tri.clone()] {
p.insert_object(0, o, &CharProps::default()).unwrap();
}
let d = doc_with(vec![p]);
let bytes = wordcraft_docx::write(&d).unwrap();
let mut z = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(z.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert_eq!(xml.matches("<a:custGeom>").count(), 3, "{xml}");
assert!(xml.contains(r#"<a:path w="762000" h="254000" fill="none"><a:moveTo><a:pt x="12700" y="12700"/></a:moveTo><a:lnTo>"#), "{xml}");
assert!(xml.contains(r#"<a:alpha val="50000"/>"#) && xml.contains(r#"cap="rnd""#), "{xml}");
let r = unstacked(rt(&d));
let objs = ¶s(&r)[0].objects;
assert_eq!(objs.len(), 3);
// Written in reverse (each inserted at the start): the triangle, the highlighter, the pen.
assert_eq!(objs[0], tri, "a filled closed freeform comes back as it was");
let InlineObject::Shape { freeform: Some(m), float, stroke_width, .. } = &objs[1] else { panic!("{:?}", objs[1]) };
assert_eq!((m.ink, m.alpha, float.wrap, *stroke_width), (Some(InkTool::Highlighter), 0.5, Wrap::BehindText, 12.0));
assert_eq!(objs[2], pen, "the pen stroke comes back point for point");
}
/// Shape effects (#275): `a:effectLst` with an outer shadow, a glow and soft edges round-trips,
/// and the effect extent leaves room for them.
#[test]
fn shape_effects_round_trip() {
use wordcraft_doc::effects::{Glow, Shadow, ShapeEffects};
let effects = ShapeEffects {
shadow: Some(Shadow { color: Rgb(0x20, 0x30, 0x40), transparency: 60.0, blur: 4.0, distance: 3.0, angle: 135.0, rot_with_shape: false }),
glow: Some(Glow { color: Rgb(0xC0, 0x50, 0x10), size: 8.0, transparency: 40.0 }),
soft_edge: Some(2.5),
};
let shape = InlineObject::Shape {
kind: ShapeKind::RoundedRectangle,
w: 100.0,
h: 50.0,
fill: Some(Fill::solid(Rgb(0x15, 0x60, 0x82))),
stroke: None,
stroke_width: 0.0,
float: Float::default(),
story: None,
freeform: None,
effects,
extra: Default::default(),
};
let mut p = Paragraph::with_text("x", CharProps::default());
p.insert_object(1, shape, &CharProps::default()).unwrap();
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(
xml.contains(
r#"<a:outerShdw blurRad="50800" dist="38100" dir="8100000" algn="tr" rotWithShape="0"><a:srgbClr val="203040"><a:alpha val="40000"/>"#
),
"{xml}"
);
assert!(xml.contains(r#"<a:glow rad="101600"><a:srgbClr val="C05010"><a:alpha val="60000"/>"#), "{xml}");
assert!(xml.contains(r#"<a:softEdge rad="31750"/>"#), "{xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
match paras(&r)[0].objects.first() {
Some(InlineObject::Shape { effects: got, float, .. }) => {
assert_eq!(*got, effects);
assert_eq!(float.effect_extent(), effects.extent());
}
o => panic!("{o:?}"),
}
}
#[test]
fn equation_manual_breaks_round_trip() {
use wordcraft_doc::math::{MNode, MRun, Math};
let nodes = vec![
MNode::Run(MRun::new("a=b")),
MNode::Run(MRun { brk: Some(1), ..MRun::new("+c") }),
MNode::Run(MRun { brk: Some(0), ..MRun::new("+d") }),
];
let mut d = Document::new();
let math = Math { nodes: nodes.clone(), ..Default::default() };
let mut p = Paragraph::with_text("", CharProps::default());
p.insert_object(0, InlineObject::Equation { linear: "a=b+c+d".into(), display: true, math }, &CharProps::default()).unwrap();
d.body = vec![para_block(p)];
let r = rt(&d);
let got = paras(&r).iter().flat_map(|p| p.objects.iter()).find_map(|o| match o {
InlineObject::Equation { math, .. } => Some(math.nodes.clone()),
_ => None,
});
assert_eq!(got, Some(nodes));
// Word's own settings round-trip; a document without them gets none.
assert_eq!(r.settings.math, None);
}
/// #332: rotation (`a:xfrm/@rot`, 60000ths of a degree) and flips of pictures, shapes, text boxes
/// and groups survive save and load; the effect extent written covers the rotated bounds, and
/// reading takes that overhang back out of the effects room.
#[test]
fn rotation_and_flips_round_trip() {
let mut d = Document::new();
let key = d.add_media(tiny_png(), "png");
let pic = InlineObject::Image {
media: key,
w: 100.0,
h: 50.0,
alt: String::new(),
float: Float { rot: 30.0, effect: [6.0; 4], ..Default::default() },
crop: [0.0; 4],
fx: Default::default(),
ole: None,
};
let shape = |kind, float| InlineObject::Shape {
kind,
w: 80.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(1, 2, 3))),
stroke: None,
stroke_width: 0.0,
float,
story: None,
freeform: None,
effects: Default::default(),
extra: Default::default(),
};
let square = Float { wrap: Wrap::Square, ..Default::default() };
let tri = shape(ShapeKind::Triangle, Float { rot: 90.0, flip_h: true, ..square.clone() });
let flipped = shape(ShapeKind::Rectangle, Float { rot: 315.5, flip_v: true, ..square.clone() });
let group = InlineObject::Group {
w: 120.0,
h: 60.0,
float: Float { rot: 45.0, ..square },
ch_w: 120.0,
ch_h: 60.0,
children: vec![wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: shape(ShapeKind::Ellipse, Float { rot: 10.0, ..Default::default() }) }],
canvas: None,
};
let mut p = Paragraph::with_text("turned ", CharProps::default());
for o in [pic, tri, flipped, group] {
let end = p.len();
p.insert_object(end, o, &CharProps::default()).unwrap();
}
d.body = vec![para_block(p)];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<a:xfrm rot="1800000">"#), "{xml}");
assert!(xml.contains(r#"<a:xfrm rot="5400000" flipH="1">"#), "{xml}");
assert!(xml.contains(r#"<a:xfrm rot="18930000" flipV="1">"#), "{xml}");
// The 100 × 50 picture turned 30° covers 111.6 × 93.3: 5.8 and 21.7 pt more on each side,
// plus its 6 pt of effects room.
assert!(xml.contains(r#"<wp:effectExtent l="149876" t="351163" r="149876" b="351163"/>"#), "{xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let got = ¶s(&r)[0].objects;
let spins: Vec<(f32, bool, bool)> = got.iter().map(|o| o.frame().unwrap().2).map(|f| (f.rot, f.flip_h, f.flip_v)).collect();
assert_eq!(spins, [(30.0, false, false), (90.0, true, false), (315.5, false, true), (45.0, false, false)]);
let effect = got[0].frame().unwrap().2.effect;
assert!(effect.iter().all(|e| (e - 6.0).abs() < 0.01), "{effect:?}");
assert!(got[1].frame().unwrap().2.effect.iter().all(|e| e.abs() < 0.01), "no effects room appears");
let InlineObject::Group { children, .. } = &got[3] else { panic!("{got:?}") };
assert_eq!(children[0].obj.frame().unwrap().2.rot, 10.0);
}
/// #332: a group's own turn and flips are on its `wpg:grpSpPr/a:xfrm` and its members keep
/// theirs inside it; whether a member's shadow turns with it (`rotWithShape`) survives too.
#[test]
fn rotated_group_and_shadow_rotation_round_trip() {
use wordcraft_doc::effects::{Shadow, ShapeEffects};
let member = |rot_with_shape: bool| InlineObject::Shape {
kind: ShapeKind::Rectangle,
w: 60.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(1, 2, 3))),
stroke: None,
stroke_width: 0.0,
float: Float { rot: 20.0, ..Default::default() },
story: None,
freeform: None,
effects: ShapeEffects { shadow: Some(Shadow { rot_with_shape, ..Default::default() }), ..Default::default() },
extra: Default::default(),
};
let group = InlineObject::Group {
w: 120.0,
h: 40.0,
float: Float { wrap: Wrap::Square, rot: 135.0, flip_h: true, ..Default::default() },
ch_w: 120.0,
ch_h: 40.0,
children: vec![
wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: member(true) },
wordcraft_doc::para::GroupChild { x: 60.0, y: 0.0, obj: member(false) },
],
canvas: None,
};
let mut p = Paragraph::with_text("g", CharProps::default());
p.insert_object(1, group, &CharProps::default()).unwrap();
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<wpg:grpSpPr><a:xfrm rot="8100000" flipH="1">"#), "{xml}");
assert!(xml.contains(r#"rotWithShape="1""#) && xml.contains(r#"rotWithShape="0""#), "{xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let Some(InlineObject::Group { float, children, .. }) = paras(&r)[0].objects.first() else { panic!("{:?}", paras(&r)[0].objects) };
assert_eq!((float.rot, float.flip_h, float.flip_v), (135.0, true, false));
let got: Vec<(f32, Option<bool>)> = children
.iter()
.map(|c| match &c.obj {
InlineObject::Shape { float, effects, .. } => (float.rot, effects.shadow.map(|s| s.rot_with_shape)),
o => panic!("{o:?}"),
})
.collect();
assert_eq!(got, [(20.0, Some(true)), (20.0, Some(false))]);
}
#[test]
fn bibliography_sources_round_trip() {
let mut d = Document::new();
d.sources.push(Source {
tag: "Rivera2021".into(),
kind: "book".into(),
author: "Rivera, Alex; Chen, Mei".into(),
title: "Shared Spaces".into(),
year: "2021".into(),
publisher: "Harbor Books".into(),
city: "Portland".into(),
editor: "Johnson, Robert".into(),
edition: "2nd".into(),
month: "10".into(),
day: "15".into(),
..Default::default()
});
d.sources.push(Source {
tag: "Smith2023".into(),
kind: "article".into(),
author: "Smith, John David".into(),
title: "Modern Typography".into(),
year: "2023".into(),
journal: "Design Quarterly".into(),
volume: "12".into(),
pages: "45-60".into(),
url: "https://example.com/typo".into(),
issue: "4".into(),
doi: "10.1000/182".into(),
..Default::default()
});
d.sources.push(Source {
tag: "WebSite2024".into(),
kind: "website".into(),
author: "Solo".into(),
title: "Open Fonts".into(),
year: "2024".into(),
url: "https://example.org".into(),
accessed: "2024-05-15".into(),
..Default::default()
});
d.sources.push(Source {
tag: "Chapter2025".into(),
kind: "bookSection".into(),
author: "Lee, Harper".into(),
title: "Chapter One".into(),
year: "2025".into(),
journal: "Anthology of Prose".into(),
pages: "1-20".into(),
..Default::default()
});
d.sources.push(Source {
tag: "Misc2026".into(),
kind: "other".into(),
title: "Archive Manuscript".into(),
year: "2026".into(),
city: "Oxford".into(),
..Default::default()
});
let bytes = wordcraft_docx::write(&d).expect("write");
assert_bibliography_parts(&bytes);
assert_bibliography_sources_round_trip(&bytes);
// Saved again after reading, the store keeps one relationship, from the main part.
let again = wordcraft_docx::write(&wordcraft_docx::read(&bytes).expect("read")).expect("write again");
assert_bibliography_parts(&again);
assert_eq!(wordcraft_docx::read(&again).expect("read again").sources.len(), d.sources.len());
}
/// #4848: a corporate author saves as Word's `b:Corporate`, in place of a name list (a role holds
/// one or the other), and reads back whole.
#[test]
fn a_corporate_author_round_trips() {
let mut d = Document::new();
d.sources.push(Source {
tag: "Wor20".into(),
kind: "report".into(),
corporate: "World Health Organization".into(),
title: "World report on hearing".into(),
year: "2020".into(),
editor: "Chadha, Shelly".into(),
..Default::default()
});
d.sources.push(Source {
tag: "Both".into(),
author: "Rivera, Alex".into(),
corporate: "Harbor Guild, Inc.".into(),
title: "Shared Spaces".into(),
..Default::default()
});
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes[..], craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let item_xml = String::from_utf8(zip.read("customXml/item1.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(item_xml.contains("<b:Author><b:Author><b:Corporate>World Health Organization</b:Corporate></b:Author><b:Editor>"), "{item_xml}");
assert!(item_xml.contains("<b:Corporate>Harbor Guild, Inc.</b:Corporate>"), "{item_xml}");
assert!(!item_xml.contains("<b:Last>Rivera</b:Last>"), "the corporate author takes the person authors' place: {item_xml}");
let back = wordcraft_docx::read(&bytes).expect("read");
let got: Vec<(&str, &str, &str)> = back.sources.iter().map(|s| (s.corporate.as_str(), s.author.as_str(), s.editor.as_str())).collect();
assert_eq!(got, [("World Health Organization", "", "Chadha, Shelly"), ("Harbor Guild, Inc.", "", "")]);
}
fn assert_bibliography_parts(bytes: &[u8]) {
let mut zip = craft_zip::Archive::open(bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
assert!(zip.contains("customXml/item1.xml"));
assert!(zip.contains("customXml/itemProps1.xml"));
assert!(zip.contains("customXml/_rels/item1.xml.rels"));
// The sources' data store is related from the main part's relationships only.
let rels_xml = String::from_utf8(zip.read("word/_rels/document.xml.rels", 16 << 20).unwrap().unwrap()).unwrap();
assert_eq!(rels_xml.matches("relationships/customXml\"").count(), 1, "{rels_xml}");
assert!(rels_xml.contains("Target=\"../customXml/item1.xml\""), "{rels_xml}");
let root_xml = String::from_utf8(zip.read("_rels/.rels", 16 << 20).unwrap().unwrap()).unwrap();
assert!(!root_xml.contains("relationships/customXml\""), "{root_xml}");
let ct_xml = String::from_utf8(zip.read("[Content_Types].xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(ct_xml.contains("PartName=\"/customXml/item1.xml\""), "{ct_xml}");
assert!(ct_xml.contains("PartName=\"/customXml/itemProps1.xml\""), "{ct_xml}");
let item_xml = String::from_utf8(zip.read("customXml/item1.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert_bibliography_types(&item_xml);
assert_bibliography_people(&item_xml);
assert_bibliography_details(&item_xml);
}
fn assert_bibliography_types(item_xml: &str) {
assert!(item_xml.contains("SelectedStyle=\"\\APA.XSL\""), "{item_xml}");
assert!(item_xml.contains("StyleName=\"APA\""), "{item_xml}");
assert!(item_xml.contains("<b:SourceType>Book</b:SourceType>"), "{item_xml}");
assert!(item_xml.contains("<b:SourceType>JournalArticle</b:SourceType>"), "{item_xml}");
assert!(item_xml.contains("<b:SourceType>InternetSite</b:SourceType>"), "{item_xml}");
assert!(item_xml.contains("<b:SourceType>BookSection</b:SourceType>"), "{item_xml}");
assert!(item_xml.contains("<b:SourceType>Misc</b:SourceType>"), "{item_xml}");
}
fn assert_bibliography_people(item_xml: &str) {
assert!(item_xml.contains("<b:Author><b:Author><b:NameList><b:Person>"), "{item_xml}");
assert!(item_xml.contains("<b:Last>Rivera</b:Last><b:First>Alex</b:First>"), "{item_xml}");
assert!(item_xml.contains("<b:Last>Smith</b:Last><b:First>John</b:First><b:Middle>David</b:Middle>"), "{item_xml}");
assert!(item_xml.contains("<b:Last>Solo</b:Last>"), "{item_xml}");
assert!(item_xml.contains("<b:Editor>"), "{item_xml}");
assert!(item_xml.contains("<b:Last>Johnson</b:Last><b:First>Robert</b:First>"), "{item_xml}");
}
fn assert_bibliography_details(item_xml: &str) {
assert!(item_xml.contains("<b:Edition>2nd</b:Edition>"), "{item_xml}");
assert!(item_xml.contains("<b:Month>10</b:Month>"), "{item_xml}");
assert!(item_xml.contains("<b:Day>15</b:Day>"), "{item_xml}");
assert!(item_xml.contains("<b:Issue>4</b:Issue>"), "{item_xml}");
assert!(item_xml.contains("<b:DOI>10.1000/182</b:DOI>"), "{item_xml}");
assert!(item_xml.contains("<b:YearAccessed>2024</b:YearAccessed>"), "{item_xml}");
assert!(item_xml.contains("<b:MonthAccessed>05</b:MonthAccessed>"), "{item_xml}");
assert!(item_xml.contains("<b:DayAccessed>15</b:DayAccessed>"), "{item_xml}");
assert!(item_xml.contains("<b:Accessed>2024-05-15</b:Accessed>"), "{item_xml}");
}
fn assert_bibliography_sources_round_trip(bytes: &[u8]) {
let back = wordcraft_docx::read(bytes).expect("read");
assert_eq!(back.sources.len(), 5);
assert_bibliography_source_0(&back.sources[0]);
assert_bibliography_source_1(&back.sources[1]);
assert_bibliography_source_2(&back.sources[2]);
assert_bibliography_source_3(&back.sources[3]);
assert_bibliography_source_4(&back.sources[4]);
}
fn assert_bibliography_source_0(source: &Source) {
assert_eq!(source.tag, "Rivera2021");
assert_eq!(source.kind, "book");
assert_eq!(source.author, "Rivera, Alex; Chen, Mei");
assert_eq!(source.title, "Shared Spaces");
assert_eq!(source.year, "2021");
assert_eq!(source.publisher, "Harbor Books");
assert_eq!(source.city, "Portland");
assert_eq!(source.editor, "Johnson, Robert");
assert_eq!(source.edition, "2nd");
assert_eq!(source.month, "10");
assert_eq!(source.day, "15");
}
fn assert_bibliography_source_1(source: &Source) {
assert_eq!(source.tag, "Smith2023");
assert_eq!(source.kind, "article");
assert_eq!(source.author, "Smith, John David");
assert_eq!(source.title, "Modern Typography");
assert_eq!(source.journal, "Design Quarterly");
assert_eq!(source.volume, "12");
assert_eq!(source.pages, "45-60");
assert_eq!(source.url, "https://example.com/typo");
assert_eq!(source.issue, "4");
assert_eq!(source.doi, "10.1000/182");
}
fn assert_bibliography_source_2(source: &Source) {
assert_eq!(source.tag, "WebSite2024");
assert_eq!(source.kind, "website");
assert_eq!(source.author, "Solo");
assert_eq!(source.title, "Open Fonts");
assert_eq!(source.url, "https://example.org");
assert_eq!(source.accessed, "2024-05-15");
}
fn assert_bibliography_source_3(source: &Source) {
assert_eq!(source.tag, "Chapter2025");
assert_eq!(source.kind, "bookSection");
assert_eq!(source.author, "Lee, Harper");
assert_eq!(source.title, "Chapter One");
assert_eq!(source.journal, "Anthology of Prose");
assert_eq!(source.pages, "1-20");
}
fn assert_bibliography_source_4(source: &Source) {
assert_eq!(source.tag, "Misc2026");
assert_eq!(source.kind, "other");
assert_eq!(source.title, "Archive Manuscript");
assert_eq!(source.city, "Oxford");
}
#[test]
fn wrap_polygons_round_trip() {
use wordcraft_doc::wrap::{WrapPolygon, shape_outline};
let mut d = Document::new();
let shape = |kind, float| InlineObject::Shape {
kind,
w: 80.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(1, 2, 3))),
stroke: None,
stroke_width: 0.0,
float,
story: None,
effects: Default::default(),
freeform: None,
extra: Default::default(),
};
// A hand-edited polygon, including points outside the frame.
let poly = WrapPolygon::new(true, [(-300, 0), (21_600, 1200), (18_000, 21_900), (0, 21_600)]).map(Arc::new);
let edited = Float { wrap: Wrap::Tight, v_rel: Anchor::Paragraph, wrap_polygon: poly.clone(), ..Default::default() };
// None: Through wrapping needs one, so the ellipse's own outline is written.
let derived = Float { wrap: Wrap::Through, ..Default::default() };
let mut p = Paragraph::with_text("wrapped ", CharProps::default());
for o in [shape(ShapeKind::Rectangle, edited.clone()), shape(ShapeKind::Ellipse, derived)] {
let end = p.len();
p.insert_object(end, o, &CharProps::default()).unwrap();
}
d.body = vec![para_block(p)];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<wp:wrapPolygon edited="1"><wp:start x="-300" y="0"/><wp:lineTo x="21600" y="1200"/>"#), "{xml}");
assert!(xml.contains(r#"<wp:lineTo x="-300" y="0"/></wp:wrapPolygon>"#), "closed: {xml}");
let r = unstacked(wordcraft_docx::read(&bytes).expect("read"));
let got = paras(&r)[0];
let floats: Vec<Float> = got.objects.iter().filter_map(|o| o.frame().map(|(_, _, f)| f.clone())).collect();
assert_eq!(floats[0], edited);
let ellipse = WrapPolygon::from_unit(false, &shape_outline(ShapeKind::Ellipse, 80.0, 40.0, None).unwrap());
assert_eq!(floats[1].wrap, Wrap::Through);
assert_eq!(floats[1].wrap_polygon.as_deref(), ellipse.as_ref());
}
/// Enclosed characters (#297) are written as Word stores them — an `eq \o\ac(○,字)` field with no
/// result, the symbol and the text in runs of their own sizes — and read back with their style,
/// whether the field's size is set on the run or comes from the styles.
#[test]
fn enclosed_characters_round_trip_in_words_structure() {
use wordcraft_doc::eq::{EncloseShape, EncloseStyle, Enclosure};
let mut p = Paragraph::new();
let cases = [
(EncloseShape::Circle, EncloseStyle::Shrink, Some(11.0)),
(EncloseShape::Triangle, EncloseStyle::Enlarge, Some(11.0)),
(EncloseShape::Square, EncloseStyle::Shrink, None),
(EncloseShape::Diamond, EncloseStyle::Enlarge, None),
];
for (shape, style, size) in cases {
let e = Enclosure { shape, style, text: "字".into() };
let off = p.len();
p.insert_object(
off,
InlineObject::Field { instr: e.instr(), result: "字".into(), locked: false, dirty: false, code: false, form: String::new() },
&CharProps { size, ..Default::default() },
)
.unwrap();
}
let doc = doc_with(vec![p]);
let bytes = wordcraft_docx::write(&doc).unwrap();
let mut z = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(z.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"<w:instrText xml:space="preserve"> eq \o\ac(○</w:instrText>"#), "{xml}");
assert!(!xml.contains("separate") && !xml.contains("enlarge"), "{xml}");
// Shrink text at 11 pt: the character at 7.5 pt (half-points 15), raised.
assert!(xml.contains(r#"<w:sz w:val="15"/>"#), "{xml}");
let back = wordcraft_docx::read(&bytes).unwrap();
let got: Vec<Enclosure> = paras(&back)[0]
.objects
.iter()
.filter_map(|o| if let InlineObject::Field { instr, result, .. } = o { Enclosure::parse(instr).filter(|_| result == "字") } else { None })
.collect();
let want: Vec<Enclosure> = cases.iter().map(|(shape, style, _)| Enclosure { shape: *shape, style: *style, text: "字".into() }).collect();
assert_eq!(got, want);
}
#[test]
fn ruby_phonetic_guide_round_trips_as_w_ruby() {
use wordcraft_doc::para::RubyAlign;
let mut p = Paragraph::with_text("Read daily.", CharProps::default());
let bold = CharProps { bold: Some(true), ..Default::default() };
let ruby = InlineObject::Ruby {
base: "漢字".into(),
ruby: "かんじ".into(),
align: RubyAlign::DistributeSpace,
size: 5.5,
raise: 10.0,
base_size: 11.0,
lang: "ja-JP".into(),
props: Box::new(CharProps { font: Some("Noto Sans CJK JP".into()), ..Default::default() }),
};
p.insert_object(5, ruby.clone(), &bold).unwrap();
let d = doc_with(vec![p]);
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
for part in [
r#"<w:rubyAlign w:val="distributeSpace"/><w:hps w:val="11"/><w:hpsRaise w:val="20"/><w:hpsBaseText w:val="22"/><w:lid w:val="ja-JP"/>"#,
"<w:rt><w:r>",
">かんじ</w:t>",
"<w:rubyBase><w:r><w:rPr><w:b/>",
">漢字</w:t>",
] {
assert!(xml.contains(part), "missing {part}: {xml}");
}
let r = wordcraft_docx::read(&bytes).expect("read");
let q = paras(&r)[0];
assert_eq!(q.plain_text(), "Read 漢字 daily.");
assert_eq!(q.objects, vec![ruby]);
assert_eq!(q.props_of_char(5).bold, Some(true));
}
/// #354: the sides text wraps on (`@wrapText`) are read and written for Square, Tight and
/// Through; both sides is the default.
#[test]
fn wrap_text_sides_round_trip() {
use wordcraft_doc::para::WrapText;
let mut d = Document::new();
let shape = |float| InlineObject::Shape {
kind: ShapeKind::Rectangle,
w: 80.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(1, 2, 3))),
stroke: None,
stroke_width: 0.0,
float,
story: None,
effects: Default::default(),
freeform: None,
extra: Default::default(),
};
let sides =
[(Wrap::Square, WrapText::Left), (Wrap::Tight, WrapText::Right), (Wrap::Through, WrapText::Largest), (Wrap::Square, WrapText::BothSides)];
let mut p = Paragraph::with_text("wrapped ", CharProps::default());
for (wrap, side) in sides {
let end = p.len();
p.insert_object(end, shape(Float { wrap, wrap_text: side, v_rel: Anchor::Paragraph, ..Default::default() }), &CharProps::default()).unwrap();
}
d.body = vec![para_block(p)];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
for tag in [
r#"<wp:wrapSquare wrapText="left"/>"#,
r#"<wp:wrapTight wrapText="right">"#,
r#"<wp:wrapThrough wrapText="largest">"#,
r#"<wp:wrapSquare wrapText="bothSides"/>"#,
] {
assert!(xml.contains(tag), "{tag}: {xml}");
}
let r = wordcraft_docx::read(&bytes).expect("read");
let got: Vec<_> = paras(&r)[0].objects.iter().filter_map(|o| o.frame().map(|(_, _, f)| (f.wrap, f.wrap_text))).collect();
assert_eq!(got, sides);
// A value outside the schema is no side (read as both sides).
assert_eq!(WrapText::from_ooxml("middle"), None);
}
#[test]
fn alt_text_title_and_decorative_round_trip_for_every_object() {
use wordcraft_doc::para::AltText;
let mut d = Document::new();
let key = d.add_media(tiny_png(), "png");
let pic = InlineObject::Image {
media: key,
w: 100.0,
h: 50.0,
alt: "A kiln at dusk".into(),
float: Float { alt: AltText { title: "Kiln".into(), ..Default::default() }, ..Default::default() },
crop: [0.0; 4],
fx: Default::default(),
ole: None,
};
let shape = |alt: AltText| InlineObject::Shape {
kind: ShapeKind::Ellipse,
w: 80.0,
h: 40.0,
fill: Some(Fill::solid(Rgb(1, 2, 3))),
stroke: None,
stroke_width: 0.0,
float: Float { alt, ..Default::default() },
story: None,
effects: Default::default(),
freeform: None,
extra: Default::default(),
};
let described = shape(AltText { text: "Process flow & \"steps\"".into(), ..Default::default() });
let decorative = shape(AltText { decorative: true, ..Default::default() });
let group = InlineObject::Group {
w: 120.0,
h: 60.0,
float: Float { alt: AltText { text: "Two circles".into(), ..Default::default() }, ..Default::default() },
ch_w: 120.0,
ch_h: 60.0,
children: vec![wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: shape(AltText { text: "Left circle".into(), ..Default::default() }) }],
canvas: None,
};
let mut p = Paragraph::with_text("objects ", CharProps::default());
for o in [pic, described, decorative, group] {
let end = p.len();
p.insert_object(end, o, &CharProps::default()).unwrap();
}
let mut t = Table::new(2, 2, 300.0);
t.props.caption = Some("Prices".into());
t.props.description = Some("Prices by year".into());
d.body = vec![para_block(p), Arc::new(Block::Table(t))];
let bytes = wordcraft_docx::write(&d).expect("write");
let mut zip = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(zip.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"{C183D7F6-B498-43B3-948B-1728B52AA6E4}"><adec:decorative xmlns:adec="http://schemas.microsoft.com/office/drawing/2017/decorative" val="1"/>"#), "{xml}");
assert!(
xml.contains(r#"<w:tblLook "#) && xml.contains(r#"<w:tblCaption w:val="Prices"/><w:tblDescription w:val="Prices by year"/></w:tblPr>"#),
"{xml}"
);
let r = wordcraft_docx::read(&bytes).expect("read");
let objs = ¶s(&r)[0].objects;
let alts: Vec<_> =
objs.iter().map(|o| (o.alt_text().to_string(), o.frame().map(|f| f.2.alt.title.clone()).unwrap_or_default(), o.is_decorative())).collect();
assert_eq!(
alts,
[
("A kiln at dusk".into(), "Kiln".into(), false),
("Process flow & \"steps\"".into(), String::new(), false),
(String::new(), String::new(), true),
("Two circles".into(), String::new(), false),
]
);
let InlineObject::Group { children, .. } = &objs[3] else { panic!("{objs:?}") };
assert_eq!(children[0].obj.alt_text(), "Left circle");
let Some(Block::Table(t)) = r.body.iter().map(|b| &**b).find(|b| matches!(b, Block::Table(_))) else { panic!() };
assert_eq!((t.props.caption.as_deref(), t.props.description.as_deref()), (Some("Prices"), Some("Prices by year")));
}
/// WordArt's warp (`a:prstTxWarp` with its adjust value) and connectors glued to shapes
/// (`a:stCxn`/`a:endCxn`, with arrowheads) come back as saved; a shape no connector is glued to
/// loses its drawing id, and hostile values are reduced.
#[test]
fn warps_and_glued_connectors_round_trip() {
use wordcraft_doc::connector::{ConnEnd, ShapeExtra};
use wordcraft_doc::wordart::TextWarp;
let mut d = Document::new();
let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Bent", CharProps::default()))]);
let float = |x: f32| Float { wrap: Wrap::InFrontOfText, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x, y: 10.0, ..Default::default() };
let shape = |kind, story, extra| InlineObject::Shape {
kind,
w: 72.0,
h: 36.0,
fill: None,
stroke: Some(Rgb(0, 0, 0)),
stroke_width: 1.0,
float: float(0.0),
story,
freeform: None,
effects: Default::default(),
extra,
};
let mut warp = TextWarp::new("textArchUp").unwrap();
warp.set_adj("adj", 9_000_000);
let art = shape(ShapeKind::TextBox, Some(story), ShapeExtra { id: 5, warp: Some(warp), ..Default::default() });
let target = shape(ShapeKind::Ellipse, None, ShapeExtra { id: 7, ..Default::default() });
let lonely = shape(ShapeKind::Rectangle, None, ShapeExtra { id: 9, ..Default::default() });
let link = ShapeExtra { start: Some(ConnEnd { id: 5, site: 3 }), end: Some(ConnEnd { id: 7, site: 2 }), arrow_end: true, ..Default::default() };
let mut conn = shape(ShapeKind::ElbowConnector, None, link);
if let InlineObject::Shape { float: f, .. } = &mut conn {
*f = Float { flip_v: true, ..float(80.0) };
}
let mut p = Paragraph::with_text("", CharProps::default());
for o in [art.clone(), conn.clone(), target.clone(), lonely] {
let end = p.len();
p.insert_object(end, o, &CharProps::default()).unwrap();
}
d.body = vec![para_block(p)];
let r = rt(&d);
let got = ¶s(&r)[0].objects;
// The glued-to shapes keep their ids, the connector its ends, arrowhead and flip.
let extra = |o: &InlineObject| match o {
InlineObject::Shape { extra, .. } => extra.clone(),
_ => panic!("{o:?}"),
};
assert_eq!(extra(&got[0]), extra(&art));
assert_eq!(extra(&got[1]), extra(&conn));
assert!(matches!(&got[1], InlineObject::Shape { kind: ShapeKind::ElbowConnector, float, .. } if float.flip_v));
assert_eq!(extra(&got[2]), extra(&target));
assert_eq!(extra(&got[3]).id, 0, "nothing is glued to it");
// Hostile: an unknown warp, a huge adjust value, a glue to a missing shape.
let xml = wordcraft_docx::write(&r).unwrap();
let mut pkg = craft_zip::Archive::open(&xml, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let doc_xml = String::from_utf8(pkg.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
let doc_xml = doc_xml
.replace("prst=\"textArchUp\"", "prst=\"textNotAWarp\"")
.replace("a:stCxn id=\"5\" idx=\"3\"", "a:stCxn id=\"404\" idx=\"99999999999\"");
let bytes = replace_part(&wordcraft_docx::write(&r).unwrap(), "word/document.xml", doc_xml.as_bytes());
let h = wordcraft_docx::read(&bytes).unwrap();
let got = ¶s(&h)[0].objects;
assert_eq!(extra(&got[0]).warp, None);
assert_eq!(extra(&got[1]).start, Some(ConnEnd { id: 404, site: wordcraft_doc::connector::MAX_SITE }));
}
/// `zip` with part `name` replaced by `data`.
fn replace_part(zip_bytes: &[u8], name: &str, data: &[u8]) -> Vec<u8> {
let mut src = craft_zip::Archive::open(zip_bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let names: Vec<String> = src.names().map(|n| n.into_owned()).collect();
let mut out = craft_zip::Writer::new();
for n in names {
if n == name {
out.add(&n, data, craft_zip::Compression::Deflated).unwrap();
} else {
let bytes = src.read(&n, 16 << 20).unwrap().unwrap();
out.add(&n, &bytes, craft_zip::Compression::Deflated).unwrap();
}
}
out.finish().unwrap()
}
/// A texture or picture page background (`v:background/v:fill`) survives a save (#999): the image
/// part, its relationship and the fill attributes.
#[test]
fn page_background_picture_round_trips() {
let png = wordcraft_geom::picture::encode_format(
&image::DynamicImage::from(image::RgbaImage::from_pixel(4, 4, image::Rgba([200, 150, 100, 255])).clone()),
image::ImageFormat::Png,
)
.unwrap();
let mut d = Document::new();
d.settings.page_color = Some(Rgb(0xFF, 0xFF, 0xCC));
d.media.insert("paper.png".into(), Arc::new(png.clone()));
d.settings.page_picture = Some(wordcraft_doc::PagePicture { media: "paper.png".into(), fill_type: "tile".into(), title: "Paper".into() });
let r = rt(&d);
let pic = r.settings.page_picture.as_ref().expect("picture kept");
assert_eq!((pic.fill_type.as_str(), pic.title.as_str()), ("tile", "Paper"));
assert_eq!(r.media.get(&pic.media).map(|b| b.as_slice()), Some(png.as_slice()));
assert_eq!(r.settings.page_color, d.settings.page_color);
// Saved again, it is still there.
assert!(rt(&r).settings.page_picture.is_some());
}
/// #2601: Drop Cap Options — a dropped cap with its lines, distance from the text and font, and
/// one in the margin, survive a save: `w:framePr w:dropCap="drop|margin" w:lines w:hSpace` on the
/// letter's own paragraph, the font on the letter's run (ECMA-376 §17.3.1.11). The text after the
/// letter keeps its own font.
#[test]
fn drop_cap_options_round_trip() {
let body = CharProps { font: Some("Liberation Serif".into()), ..Default::default() };
let mut dropped = Paragraph::with_text("Once upon a time", body.clone());
dropped.props.drop_cap = Some(2);
dropped.props.drop_cap_distance = Some(6.0);
dropped.props.drop_cap_font = Some("Liberation Mono".into());
let mut margin = Paragraph::with_text("In the margin", body.clone());
margin.props.drop_cap = Some(4);
margin.props.drop_cap_margin = Some(true);
let d = doc_with(vec![dropped, margin]);
let bytes = wordcraft_docx::write(&d).expect("write");
let mut z = craft_zip::Archive::open(&bytes, craft_zip::Limits { max_entries: 10_000, max_total_bytes: 64 << 20 }).unwrap();
let xml = String::from_utf8(z.read("word/document.xml", 16 << 20).unwrap().unwrap()).unwrap();
assert!(xml.contains(r#"w:dropCap="drop" w:lines="2" w:hSpace="120""#), "{xml}");
assert!(xml.contains(r#"w:dropCap="margin" w:lines="4""#), "{xml}");
assert!(xml.contains(r#"w:ascii="Liberation Mono""#), "the letter's font on its run: {xml}");
let r = wordcraft_docx::read(&bytes).expect("read");
let got = paras(&r);
assert_eq!(got.len(), 2, "each letter merges back into its paragraph");
let (a, b) = (&got[0], &got[1]);
assert_eq!(a.plain_text(), "Once upon a time");
assert_eq!(
(a.props.drop_cap, a.props.drop_cap_margin, a.props.drop_cap_distance, a.props.drop_cap_font.as_deref()),
(Some(2), None, Some(6.0), Some("Liberation Mono"))
);
assert!(a.runs.iter().all(|r| r.props.font.as_deref() == Some("Liberation Serif")), "the letter keeps the text's font: {:?}", a.runs);
assert_eq!(b.plain_text(), "In the margin");
assert_eq!(
(b.props.drop_cap, b.props.drop_cap_margin, b.props.drop_cap_distance, b.props.drop_cap_font.as_deref()),
(Some(4), Some(true), None, None)
);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.