Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

25.4 KB
Raw Blame
use crate::edit::{EditOp, EditResult, Editor};
use crate::inspect::{MasterLayoutOutline, ShapeOutline, SlideOutline};
use crate::model::masters::MASTER_ID_BASE;
use crate::model::presentation::Presentation;
use crate::test_support::fonts;
use serde_json::json;

/// A corpus deck: slide 1 uses "Title Slide", slide 2 "Title and Content",
/// slides 3-8 "Title Only"; eight of its eleven layouts are unused.
fn kitchen_sink() -> Presentation {
    let path = concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/tests/corpus/generated/kitchen-sink-financial.pptx"
    );
    Presentation::open(std::fs::read(path).unwrap()).unwrap()
}

fn apply(pres: &mut Presentation, ops: serde_json::Value) -> EditResult {
    let ops: Vec<EditOp> = serde_json::from_value(ops).unwrap();
    pres.apply(&ops, fonts()).unwrap()
}

fn refused(pres: &mut Presentation, ops: serde_json::Value) -> String {
    let ops: Vec<EditOp> = serde_json::from_value(ops).unwrap();
    pres.apply(&ops, fonts()).unwrap_err().to_string()
}

fn layout(pres: &mut Presentation, name: &str) -> MasterLayoutOutline {
    let outline = pres.outline().unwrap();
    outline.masters[0]
        .layouts
        .iter()
        .find(|l| l.name == name)
        .cloned()
        .unwrap_or_else(|| panic!("no layout {name}"))
}

fn layout_names(pres: &mut Presentation) -> Vec<String> {
    pres.outline().unwrap().masters[0]
        .layouts
        .iter()
        .map(|l| l.name.clone())
        .collect()
}

fn page(pres: &mut Presentation, id: u32) -> SlideOutline {
    pres.slide_outline(id as usize).unwrap()
}

fn placeholder<'a>(page: &'a SlideOutline, kind: &str) -> &'a ShapeOutline {
    page.shapes
        .iter()
        .find(|s| s.placeholder.as_deref() == Some(kind))
        .unwrap_or_else(|| panic!("no {kind} placeholder"))
}

fn reopen(pres: &mut Presentation) -> Presentation {
    let mut reopened = Presentation::open(pres.save().unwrap()).unwrap();
    let problems = reopened.integrity_problems().unwrap();
    assert!(problems.is_empty(), "{problems:#?}");
    reopened
}

fn render(pres: &mut Presentation, index: usize) -> Vec<u8> {
    pres.render_slide(index, 320, fonts())
        .unwrap()
        .to_straight_rgba()
}

#[test]
fn the_outline_lists_the_master_and_its_layouts_with_their_slides() {
    let mut pres = kitchen_sink();
    let outline = pres.outline().unwrap();
    assert_eq!(outline.masters.len(), 1);
    let master = &outline.masters[0];
    assert!(master.id >= MASTER_ID_BASE);
    assert_eq!(master.name, "Office Theme");
    assert_eq!(master.layouts.len(), 11);
    assert_eq!(
        master.placeholders,
        ["title", "body", "dt", "ftr", "sldNum"]
    );
    let title_only = master
        .layouts
        .iter()
        .find(|l| l.name == "Title Only")
        .unwrap();
    assert_eq!(title_only.slide_ids, [258, 259, 260, 261, 262, 263]);
    assert_eq!(title_only.kind, "titleOnly");
    assert_eq!(title_only.placeholders, ["title", "dt", "ftr", "sldNum"]);
    let blank = master.layouts.iter().find(|l| l.name == "Blank").unwrap();
    assert!(blank.slide_ids.is_empty());
    // Slides name their layout by id too.
    assert_eq!(outline.slides[2].layout_id, Some(title_only.id));
}

#[test]
fn a_layout_reads_like_a_slide_by_its_id() {
    let mut pres = kitchen_sink();
    let content = layout(&mut pres, "Title and Content");
    let outline = page(&mut pres, content.id);
    assert_eq!(outline.id, content.id);
    assert_eq!(outline.index, 2, "the master, then its layouts");
    assert_eq!(outline.layout, "Title and Content");
    assert_eq!(outline.layout_id, Some(content.id));
    assert!(outline.notes.is_none());
    let body = placeholder(&outline, "obj");
    assert_eq!(body.placeholder_index, Some(1));
    assert_eq!(body.paragraphs[0].text, "Click to edit Master text styles");
    // Caret layout of the layout's title, styled by the master's title style.
    let title = placeholder(&outline, "title").id;
    let text = pres
        .text_layout(content.id as usize, title, None, fonts())
        .unwrap()
        .unwrap();
    assert_eq!(text.paragraphs[0], "Click to edit Master title style");
    assert_eq!(text.styles[0].runs[0].size, 44.0);
    // The master itself, with its own text styles.
    let master = pres.outline().unwrap().masters[0].id;
    let outline = page(&mut pres, master);
    assert_eq!(outline.index, 0);
    assert_eq!(outline.layout, "Office Theme");
    assert_eq!(outline.layout_id, None);
    let title = placeholder(&outline, "title").id;
    let text = pres
        .text_layout(master as usize, title, None, fonts())
        .unwrap()
        .unwrap();
    assert_eq!(text.styles[0].runs[0].size, 44.0);
    // Pages render, and a slide number placeholder shows its ‹#› field.
    assert!(render(&mut pres, master as usize).iter().any(|&b| b != 255));
    let number = placeholder(&outline, "sldNum").id;
    let text = pres
        .text_layout(master as usize, number, None, fonts())
        .unwrap()
        .unwrap();
    assert_eq!(text.paragraphs[0], "‹#›");
    // Ids that are neither slides nor masters are refused.
    assert!(pres.slide_outline(MASTER_ID_BASE as usize + 999).is_err());
    assert!(pres.slide_outline(99).is_err());
}

#[test]
fn editing_a_layout_changes_only_the_slides_that_use_it() {
    let mut pres = kitchen_sink();
    let title_only = layout(&mut pres, "Title Only");
    let title = placeholder(&page(&mut pres, title_only.id), "title").id;
    let using = pres.slides().iter().position(|s| s.id == 258).unwrap();
    let other = pres.slides().iter().position(|s| s.id == 256).unwrap();
    let (before_using, before_other) = (render(&mut pres, using), render(&mut pres, other));
    let result = apply(
        &mut pres,
        json!([{"op": "formatText", "slide": title_only.id, "shape": title,
                "props": {"bold": true, "color": "C00000", "size": 40}}]),
    );
    assert_eq!(result.changed_slides, title_only.slide_ids);
    assert_eq!(result.changed_layouts, [title_only.id]);
    assert!(!result.structure_changed);
    assert_ne!(render(&mut pres, using), before_using);
    assert_eq!(render(&mut pres, other), before_other);
    // The slide's title inherits the layout's formatting.
    let slide = pres.slide_outline(using).unwrap();
    let slide_title = placeholder(&slide, "title").id;
    let text = pres
        .text_layout(using, slide_title, None, fonts())
        .unwrap()
        .unwrap();
    let run = &text.styles[0].runs[0];
    assert!(run.bold);
    assert_eq!(run.color.as_deref(), Some("#C00000"));
    // The slide's own size wins over the layout's.
    assert_eq!(run.size, 28.0);
    // A slide whose title has no size of its own takes the layout's.
    let result = apply(
        &mut pres,
        json!([{"op": "addSlide", "layout": "Title Only", "title": "New"}]),
    );
    let added = pres
        .slides()
        .iter()
        .position(|s| s.id == result.created[0].slide)
        .unwrap();
    let added_title = placeholder(&pres.slide_outline(added).unwrap(), "title").id;
    let text = pres
        .text_layout(added, added_title, None, fonts())
        .unwrap()
        .unwrap();
    assert_eq!(text.styles[0].runs[0].size, 40.0);
    // Paragraph formatting carries over too.
    apply(
        &mut pres,
        json!([{"op": "formatParagraphs", "slide": title_only.id, "shape": title,
                "props": {"align": "right"}}]),
    );
    let text = pres
        .text_layout(using, slide_title, None, fonts())
        .unwrap()
        .unwrap();
    assert_eq!(text.styles[0].align, "right");
    // Formatting part of the text stays with the layout's own text.
    apply(
        &mut pres,
        json!([{"op": "formatText", "slide": title_only.id, "shape": title,
                "start": {"paragraph": 0, "offset": 0}, "end": {"paragraph": 0, "offset": 5},
                "props": {"italic": true}}]),
    );
    let text = pres
        .text_layout(using, slide_title, None, fonts())
        .unwrap()
        .unwrap();
    assert!(!text.styles[0].runs[0].italic);
    // It survives a save.
    let mut reopened = reopen(&mut pres);
    let text = reopened
        .text_layout(using, slide_title, None, fonts())
        .unwrap()
        .unwrap();
    assert!(text.styles[0].runs[0].bold);
    assert_eq!(text.styles[0].align, "right");
}

#[test]
fn editing_the_master_changes_every_slide_and_page() {
    let mut pres = kitchen_sink();
    let outline = pres.outline().unwrap();
    let master = outline.masters[0].id;
    let before = render(&mut pres, 2);
    let result = apply(
        &mut pres,
        json!([{"op": "addShape", "slide": master,
                "shape": {"kind": "shape", "preset": "rect"},
                "x": 0, "y": 0, "w": 40, "h": 40}]),
    );
    let created = result.created[0].shape.unwrap();
    assert_eq!(result.changed_slides.len(), outline.slides.len());
    assert_eq!(
        result.changed_layouts.len(),
        1 + outline.masters[0].layouts.len()
    );
    assert!(
        page(&mut pres, master)
            .shapes
            .iter()
            .any(|s| s.id == created)
    );
    // Hiding background graphics on a layout keeps master shapes off it.
    let title_only = layout(&mut pres, "Title Only");
    assert_ne!(render(&mut pres, 2), before);
    let result = apply(
        &mut pres,
        json!([{"op": "setLayoutOptions", "layout": title_only.id,
                "hideBackgroundGraphics": true}]),
    );
    assert!(
        result.structure_changed,
        "Slide Master view shows the option"
    );
    assert!(layout(&mut pres, "Title Only").hide_background_graphics);
    assert_eq!(render(&mut pres, 2), before);
}

#[test]
fn backgrounds_set_on_a_layout_show_on_its_slides() {
    let mut pres = kitchen_sink();
    let title_only = layout(&mut pres, "Title Only");
    apply(
        &mut pres,
        json!([{"op": "setBackground", "slide": title_only.id,
                "fill": {"kind": "solid", "color": "00FF00"}}]),
    );
    let green = |pixels: Vec<u8>| pixels.chunks(4).filter(|p| *p == [0, 255, 0, 255]).count();
    let using = pres.slides().iter().position(|s| s.id == 258).unwrap();
    assert!(green(render(&mut pres, using)) > 1000);
    assert_eq!(
        &render(&mut pres, title_only.id as usize)[..4],
        &[0, 255, 0, 255]
    );
    assert_eq!(green(render(&mut pres, 0)), 0);
}

#[test]
fn background_styles_follow_the_theme() {
    let mut pres = kitchen_sink();
    let title_only = layout(&mut pres, "Title Only");
    let corner = |pres: &mut Presentation| render(pres, title_only.id as usize)[..4].to_vec();
    assert_eq!(corner(&mut pres), [255, 255, 255, 255]);
    // Style 2: the first background fill in Dark 1 (black in this theme).
    apply(
        &mut pres,
        json!([{"op": "setBackgroundStyle", "slide": title_only.id, "style": 2}]),
    );
    assert_eq!(corner(&mut pres), [0, 0, 0, 255]);
    let mut reopened = reopen(&mut pres);
    let part = reopened.page_part(title_only.id).unwrap();
    let xml = String::from_utf8(reopened.read_bytes(&part).unwrap()).unwrap();
    assert!(
        xml.contains(r#"<p:bg><p:bgRef idx="1001"><a:schemeClr val="tx1"/></p:bgRef></p:bg>"#),
        "{xml}"
    );
    // Theme colors restyle it.
    apply(
        &mut pres,
        json!([{"op": "setThemeColors", "colors": [{"slot": "dk1", "color": "203040"}]}]),
    );
    assert_eq!(corner(&mut pres), [0x20, 0x30, 0x40, 255]);
    assert!(
        refused(
            &mut pres,
            json!([{"op": "setBackgroundStyle", "slide": title_only.id, "style": 13}])
        )
        .contains("1-12")
    );
}

#[test]
fn insert_layout_adds_a_titled_layout_with_footers() {
    let mut pres = kitchen_sink();
    let blank = layout(&mut pres, "Blank");
    let before = pres.master_pages().unwrap();
    let result = apply(&mut pres, json!([{"op": "addLayout", "after": blank.id}]));
    assert!(result.structure_changed);
    let id = result.created[0].slide;
    assert!(before.iter().all(|p| p.id < id), "ids grow upward");
    let names = layout_names(&mut pres);
    let at = names.iter().position(|n| n == "Blank").unwrap();
    assert_eq!(names[at + 1], "Custom Layout");
    let added = layout(&mut pres, "Custom Layout");
    assert_eq!(added.id, id);
    assert_eq!(added.kind, "cust");
    assert_eq!(added.placeholders, ["title", "dt", "ftr", "sldNum"]);
    // Its title takes the master's place.
    let master = pres.outline().unwrap().masters[0].id;
    let master_title = placeholder(&page(&mut pres, master), "title").clone();
    let title = placeholder(&page(&mut pres, id), "title").clone();
    assert_eq!(
        (title.x, title.y, title.w),
        (master_title.x, master_title.y, master_title.w)
    );
    // A second one is numbered, as PowerPoint names it.
    apply(&mut pres, json!([{"op": "addLayout", "master": master}]));
    assert_eq!(layout_names(&mut pres).last().unwrap(), "1_Custom Layout");
    // Slides can use it, and PowerPoint's rules for ids and relationships hold.
    apply(
        &mut pres,
        json!([{"op": "addSlide", "layout": "Custom Layout", "title": "Hi"}]),
    );
    let mut reopened = reopen(&mut pres);
    assert_eq!(layout(&mut reopened, "Custom Layout").slide_ids.len(), 1);
    assert_eq!(layout_names(&mut reopened).len(), 13);
}

#[test]
fn duplicate_layout_copies_it_next_to_the_original() {
    let mut pres = kitchen_sink();
    let content = layout(&mut pres, "Title and Content");
    let result = apply(
        &mut pres,
        json!([{"op": "addLayout", "duplicate": content.id}]),
    );
    let id = result.created[0].slide;
    let names = layout_names(&mut pres);
    let at = names.iter().position(|n| n == "Title and Content").unwrap();
    assert_eq!(names[at + 1], "1_Title and Content");
    let copy = layout(&mut pres, "1_Title and Content");
    assert_eq!(copy.id, id);
    assert_eq!(copy.placeholders, content.placeholders);
    assert!(copy.slide_ids.is_empty());
    // The copy is a part of its own.
    let body = placeholder(&page(&mut pres, id), "obj").id;
    apply(
        &mut pres,
        json!([{"op": "setText", "slide": id, "shape": body, "text": "Copy"}]),
    );
    let original = page(&mut pres, content.id);
    assert_ne!(placeholder(&original, "obj").paragraphs[0].text, "Copy");
    reopen(&mut pres);
}

#[test]
fn layouts_and_masters_are_renamed() {
    let mut pres = kitchen_sink();
    let blank = layout(&mut pres, "Blank");
    let master = pres.outline().unwrap().masters[0].id;
    let result = apply(
        &mut pres,
        json!([{"op": "renameLayout", "layout": blank.id, "name": "Empty"},
               {"op": "renameLayout", "layout": master, "name": "Quarterly"}]),
    );
    assert!(result.structure_changed);
    let mut reopened = reopen(&mut pres);
    let outline = reopened.outline().unwrap();
    assert_eq!(outline.masters[0].name, "Quarterly");
    assert!(outline.masters[0].layouts.iter().any(|l| l.name == "Empty"));
    assert!(outline.layouts.iter().any(|l| l.name == "Empty"));
    assert!(
        refused(
            &mut pres,
            json!([{"op": "renameLayout", "layout": blank.id, "name": " "}])
        )
        .contains("empty")
    );
}

#[test]
fn only_unused_layouts_are_deleted() {
    let mut pres = kitchen_sink();
    let title_only = layout(&mut pres, "Title Only");
    let error = refused(
        &mut pres,
        json!([{"op": "deleteLayout", "layout": title_only.id}]),
    );
    assert!(
        error.contains("slides 3, 4, 5, 6, 7 and 8 use it"),
        "{error}"
    );
    let blank = layout(&mut pres, "Blank");
    let part = pres
        .master_pages()
        .unwrap()
        .into_iter()
        .find(|p| p.id == blank.id)
        .unwrap()
        .part;
    let result = apply(
        &mut pres,
        json!([{"op": "deleteLayout", "layout": blank.id}]),
    );
    assert!(result.structure_changed);
    assert!(!layout_names(&mut pres).contains(&"Blank".to_owned()));
    assert!(!pres.package().has_part(&part));
    let overridden = pres
        .package()
        .content_types()
        .overrides()
        .any(|(name, _)| name.eq_ignore_ascii_case(&part));
    assert!(!overridden);
    let mut reopened = reopen(&mut pres);
    assert_eq!(layout_names(&mut reopened).len(), 10);
    // The deck's only master stays.
    let master = pres.outline().unwrap().masters[0].id;
    assert!(
        refused(&mut pres, json!([{"op": "deleteLayout", "layout": master}])).contains("slides")
    );
}

#[test]
fn inserted_placeholders_are_inherited_by_new_slides() {
    let mut pres = kitchen_sink();
    let title_only = layout(&mut pres, "Title Only");
    let result = apply(
        &mut pres,
        json!([
            {"op": "insertPlaceholder", "layout": title_only.id, "kind": "picture",
             "x": 60, "y": 150, "w": 300, "h": 200},
            {"op": "insertPlaceholder", "layout": title_only.id, "kind": "content",
             "x": 400, "y": 150, "w": 280, "h": 200, "vertical": null},
        ]),
    );
    let picture = result.created[0].shape.unwrap();
    let content = result.created[1].shape.unwrap();
    let outline = page(&mut pres, title_only.id);
    let pic = outline.shapes.iter().find(|s| s.id == picture).unwrap();
    assert_eq!(pic.placeholder.as_deref(), Some("pic"));
    assert_eq!(pic.paragraphs[0].text, "Picture");
    let obj = outline.shapes.iter().find(|s| s.id == content).unwrap();
    assert_eq!(obj.placeholder.as_deref(), Some("obj"));
    assert_eq!(obj.paragraphs.len(), 5);
    assert_ne!(pic.placeholder_index, obj.placeholder_index);
    assert!(pic.placeholder_index.unwrap() > 12);
    // A new slide gets both, inheriting their place.
    let result = apply(
        &mut pres,
        json!([{"op": "addSlide", "layout": "Title Only"}]),
    );
    let slide = result.created[0].slide;
    let index = pres.slides().iter().position(|s| s.id == slide).unwrap();
    let new = pres.slide_outline(index).unwrap();
    let new_pic = placeholder(&new, "pic");
    assert_eq!(new_pic.placeholder_index, pic.placeholder_index);
    assert_eq!(
        (new_pic.x, new_pic.y, new_pic.w, new_pic.h),
        (60.0, 150.0, 300.0, 200.0)
    );
    assert!(new_pic.paragraphs.is_empty());
    let new_obj = placeholder(&new, "obj");
    assert_eq!((new_obj.x, new_obj.y), (400.0, 150.0));
    // Masters take no inserted placeholders.
    let master = pres.outline().unwrap().masters[0].id;
    assert!(
        refused(
            &mut pres,
            json!([{"op": "insertPlaceholder", "layout": master, "kind": "text",
                "x": 0, "y": 0, "w": 10, "h": 10}])
        )
        .contains("not a slide layout")
    );
    reopen(&mut pres);
}

#[test]
fn title_and_footer_options_add_and_remove_placeholders() {
    let mut pres = kitchen_sink();
    let blank = layout(&mut pres, "Blank");
    assert_eq!(blank.placeholders, ["dt", "ftr", "sldNum"]);
    apply(
        &mut pres,
        json!([{"op": "setLayoutOptions", "layout": blank.id, "title": true, "footers": false}]),
    );
    assert_eq!(layout(&mut pres, "Blank").placeholders, ["title"]);
    apply(
        &mut pres,
        json!([{"op": "setLayoutOptions", "layout": blank.id, "title": false, "footers": true}]),
    );
    assert_eq!(
        layout(&mut pres, "Blank").placeholders,
        ["dt", "ftr", "sldNum"]
    );
    reopen(&mut pres);
}

#[test]
fn duplicated_layout_placeholders_get_their_own_index() {
    let mut pres = kitchen_sink();
    let content = layout(&mut pres, "Title and Content");
    let body = placeholder(&page(&mut pres, content.id), "obj").clone();
    let result = apply(
        &mut pres,
        json!([{"op": "duplicateShape", "slide": content.id, "shape": body.id}]),
    );
    let copy = result.created[0].shape.unwrap();
    let outline = page(&mut pres, content.id);
    let copy = outline.shapes.iter().find(|s| s.id == copy).unwrap();
    assert_ne!(copy.placeholder_index, body.placeholder_index);
}

#[test]
fn slide_operations_refuse_masters_and_layouts() {
    let mut pres = kitchen_sink();
    let blank = layout(&mut pres, "Blank");
    for op in [
        json!({"op": "deleteSlide", "slide": blank.id}),
        json!({"op": "setNotes", "slide": blank.id, "text": "x"}),
        json!({"op": "setSlideLayout", "slide": blank.id, "layout": "Blank"}),
    ] {
        let error = refused(&mut pres, json!([op]));
        assert!(error.contains("slide master or layout"), "{error}");
    }
}

#[test]
fn layout_edits_undo_and_redo() {
    let mut editor = Editor::new(kitchen_sink());
    let blank = layout(editor.presentation_mut(), "Blank");
    let ops: Vec<EditOp> = serde_json::from_value(json!([
        {"op": "addLayout", "after": blank.id},
        {"op": "renameLayout", "layout": blank.id, "name": "Nothing"},
    ]))
    .unwrap();
    editor.apply(&ops, None, fonts()).unwrap();
    assert_eq!(layout_names(editor.presentation_mut()).len(), 12);
    let undone = editor.undo().unwrap();
    assert!(undone.structure_changed);
    let names = layout_names(editor.presentation_mut());
    assert_eq!(names.len(), 11);
    assert!(names.contains(&"Blank".to_owned()));
    editor.redo().unwrap();
    assert!(layout_names(editor.presentation_mut()).contains(&"Nothing".to_owned()));
}

#[test]
fn collaborators_receive_new_and_edited_layouts() {
    let mut seeding = kitchen_sink();
    seeding.enable_collab(1);
    let entries = crate::collab::Entries::from_changes(&seeding.collab_changes().unwrap());
    let mut a = Presentation::from_entries(entries.clone(), 2).unwrap();
    let mut b = Presentation::from_entries(entries, 3).unwrap();
    let blank = layout(&mut a, "Blank");
    apply(
        &mut a,
        json!([{"op": "addLayout", "after": blank.id, "name": "Shared"},
               {"op": "setLayoutOptions", "layout": blank.id, "title": true}]),
    );
    let changes = a.collab_changes().unwrap();
    let result = b.apply_collab_changes(&changes).unwrap();
    assert!(result.structure_changed);
    assert!(result.changed_layouts.contains(&blank.id));
    assert_eq!(layout_names(&mut b), layout_names(&mut a));
    assert_eq!(layout(&mut b, "Blank").placeholders[0], "title");
    let shared = layout(&mut b, "Shared");
    assert!(shared.id >= MASTER_ID_BASE);
    reopen(&mut b);
}

/// Saves a deck with new, duplicated, renamed, and deleted layouts and
/// inserted placeholders, and has LibreOffice convert it to PDF. Needs
/// `soffice` (LibreOffice with Impress).
#[test]
#[ignore = "needs LibreOffice (soffice)"]
fn libreoffice_opens_a_deck_with_edited_layouts() {
    let mut pres = kitchen_sink();
    let blank = layout(&mut pres, "Blank");
    let content = layout(&mut pres, "Title and Content");
    let result = apply(
        &mut pres,
        json!([
            {"op": "addLayout", "after": blank.id, "name": "Quarter"},
            {"op": "addLayout", "duplicate": content.id},
            {"op": "deleteLayout", "layout": blank.id},
        ]),
    );
    let quarter = result.created[0].slide;
    apply(
        &mut pres,
        json!([
            {"op": "insertPlaceholder", "layout": quarter, "kind": "picture",
             "x": 60, "y": 150, "w": 300, "h": 200},
            {"op": "insertPlaceholder", "layout": quarter, "kind": "text",
             "x": 400, "y": 150, "w": 280, "h": 200},
            {"op": "addSlide", "layout": "Quarter", "title": "From a new layout"},
        ]),
    );
    let bytes = reopen(&mut pres).save().unwrap();
    let dir = std::env::temp_dir().join(format!("pptx-masters-{}", std::process::id()));
    std::fs::create_dir_all(&dir).unwrap();
    let input = dir.join("layouts.pptx");
    std::fs::write(&input, bytes).unwrap();
    let status = std::process::Command::new("soffice")
        .arg(format!(
            "-env:UserInstallation=file://{}",
            dir.join("profile").display()
        ))
        .args(["--headless", "--convert-to", "pdf", "--outdir"])
        .arg(&dir)
        .arg(&input)
        .status();
    let Ok(status) = status else {
        eprintln!("soffice is not installed; skipping");
        return;
    };
    assert!(status.success());
    let pdf = std::fs::metadata(dir.join("layouts.pdf")).unwrap();
    assert!(pdf.len() > 1000);
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn masters_and_layouts_listed_without_ids_get_lasting_ones() {
    // PowerPoint 2008 for Mac lists masters and layouts without ids.
    let mut pres = Presentation::open(crate::test_support::deck(&[""])).unwrap();
    for part in [
        "/ppt/presentation.xml",
        "/ppt/slideMasters/slideMaster1.xml",
    ] {
        let doc = pres.xml_mut(part).unwrap();
        for node in doc.descendants(doc.root()) {
            if matches!(doc.local(node), "sldMasterId" | "sldLayoutId") {
                doc.remove_attr(node, "id");
            }
        }
    }
    let mut pres = Presentation::open(pres.save().unwrap()).unwrap();
    let pages = pres.master_pages().unwrap();
    let ids: Vec<(u32, bool)> = pages.iter().map(|p| (p.id, p.stored)).collect();
    assert_eq!(ids, [(MASTER_ID_BASE, false), (MASTER_ID_BASE + 1, false)]);
    assert_eq!(pages[1].master, MASTER_ID_BASE);
    assert!(pres.integrity_problems().unwrap().is_empty());
    // They read and render by those ids, and keep them when the lists change.
    let layout = MASTER_ID_BASE + 1;
    assert_eq!(page(&mut pres, layout).layout, "Title and Content");
    let result = apply(&mut pres, json!([{"op": "addLayout", "after": layout}]));
    assert_eq!(result.created[0].slide, MASTER_ID_BASE + 2);
    let mut reopened = reopen(&mut pres);
    let pages = reopened.master_pages().unwrap();
    let ids: Vec<(u32, bool)> = pages.iter().map(|p| (p.id, p.stored)).collect();
    assert_eq!(
        ids,
        [
            (MASTER_ID_BASE, true),
            (MASTER_ID_BASE + 1, true),
            (MASTER_ID_BASE + 2, true)
        ]
    );
}