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.

21.5 KB
Raw Blame
use super::*;
use crate::edit::{EditOp, EditResult, Editor, RunPatch};
use crate::inspect::ShapeOutline;
use crate::render::scene::{Effect, Node};
use crate::test_support::{deck, fonts, text_box};
use serde_json::json;

const SLIDE: u32 = 256;

/// A filled rectangle at (100, 100) pt, 200 × 100 pt.
fn shape(id: u32, sp_pr_tail: &str, style: &str) -> String {
    format!(
        r#"<p:sp><p:nvSpPr><p:cNvPr id="{id}" name="Shape {id}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="1270000" y="1270000"/><a:ext cx="2540000" cy="1270000"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:solidFill><a:srgbClr val="4472C4"/></a:solidFill>{sp_pr_tail}</p:spPr>{style}</p:sp>"#
    )
}

/// A style whose effect reference is the test theme's third effect style
/// (an outer shadow: blur 4.5 pt, distance 1.5 pt, straight down, 63% opaque).
const THEME_SHADOW_STYLE: &str = r#"<p:style><a:lnRef idx="2"><a:schemeClr val="accent1"><a:shade val="50000"/></a:schemeClr></a:lnRef><a:fillRef idx="1"><a:schemeClr val="accent1"/></a:fillRef><a:effectRef idx="3"><a:schemeClr val="accent1"/></a:effectRef><a:fontRef idx="minor"><a:schemeClr val="lt1"/></a:fontRef></p:style>"#;

const TABLE: &str = r#"<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="9" name="Table 9"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="370840"/></p:xfrm><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/table"><a:tbl><a:tblPr/><a:tblGrid><a:gridCol w="914400"/></a:tblGrid><a:tr h="370840"><a:tc><a:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></a:txBody><a:tcPr/></a:tc></a:tr></a:tbl></a:graphicData></a:graphic></p:graphicFrame>"#;

fn open(shapes: &str) -> Presentation {
    Presentation::open(deck(&[shapes])).unwrap()
}

/// A `setShapeEffects` operation from JSON fields (as the editor and AI send them).
fn effects_op(shapes: &[u32], fields: serde_json::Value) -> EditOp {
    let mut op = json!({"op": "setShapeEffects", "slide": SLIDE, "shapes": shapes});
    for (k, v) in fields.as_object().unwrap() {
        op[k] = v.clone();
    }
    serde_json::from_value(op).unwrap()
}

fn apply(pres: &mut Presentation, op: EditOp) -> EditResult {
    pres.apply(&[op], fonts()).unwrap()
}

fn outline(pres: &mut Presentation, id: u32) -> ShapeOutline {
    let slide = pres.slide_outline(0).unwrap();
    slide.shapes.into_iter().find(|s| s.id == id).unwrap()
}

fn slide_xml(pres: &mut Presentation) -> String {
    pres.flush();
    let part = pres.slides()[0].part.clone();
    String::from_utf8(pres.package().read(&part).unwrap().into_owned()).unwrap()
}

/// The `a:effectLst` markup of the first shape that has one.
fn effect_list(pres: &mut Presentation) -> String {
    let xml = slide_xml(pres);
    let start = xml.find("<a:effectLst").expect("an effect list");
    let end = xml[start..].find("</a:effectLst>").map_or_else(
        || start + xml[start..].find("/>").unwrap() + 2,
        |e| start + e + 14,
    );
    xml[start..end].to_owned()
}

fn assert_reopens(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
}

#[test]
fn every_shadow_preset_writes_and_reads_back_by_name() {
    let mut pres = open(&shape(2, "", ""));
    for preset in SHADOW_PRESETS {
        apply(&mut pres, effects_op(&[2], json!({"shadow": preset.name})));
        let shadow = outline(&mut pres, 2).effects.unwrap().shadow.unwrap();
        assert_eq!(shadow.preset, Some(preset.name));
        assert_eq!(shadow.kind, if preset.inner { "inner" } else { "outer" });
        assert_eq!(shadow.color, "#000000");
        assert!((shadow.transparency - (1.0 - preset.alpha as f32)).abs() < 1e-3);
        assert!((shadow.blur_pt - preset.blur as f32).abs() < 1e-3);
        assert!((shadow.distance_pt - preset.dist as f32).abs() < 1e-3);
        // One shadow at a time.
        let list = effect_list(&mut pres);
        assert_eq!(list.matches("Shdw").count(), 2, "{list}");
    }
    let mut reopened = assert_reopens(&mut pres);
    let shadow = outline(&mut reopened, 2).effects.unwrap().shadow.unwrap();
    assert_eq!(shadow.preset, Some("perspectiveLowerRight"));
}

#[test]
fn gallery_shadow_markup_matches_powerpoint() {
    let mut pres = open(&shape(2, "", ""));
    apply(
        &mut pres,
        effects_op(&[2], json!({"shadow": "outerBottomRight"})),
    );
    assert_eq!(
        effect_list(&mut pres),
        r#"<a:effectLst><a:outerShdw blurRad="50800" dist="38100" dir="2700000" algn="tl" rotWithShape="0"><a:prstClr val="black"><a:alpha val="40000"/></a:prstClr></a:outerShdw></a:effectLst>"#
    );
    apply(&mut pres, effects_op(&[2], json!({"shadow": "innerTop"})));
    assert_eq!(
        effect_list(&mut pres),
        r#"<a:effectLst><a:innerShdw blurRad="63500" dist="50800" dir="5400000"><a:prstClr val="black"><a:alpha val="50000"/></a:prstClr></a:innerShdw></a:effectLst>"#
    );
}

#[test]
fn options_change_the_current_shadow() {
    let mut pres = open(&shape(2, "", ""));
    apply(
        &mut pres,
        effects_op(&[2], json!({"shadow": "outerBottom"})),
    );
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": {"color": "C00000", "transparency": 0.25, "sizePct": 110,
                              "blurPt": 8, "distancePt": 6, "angleDeg": -45, "preset": null}}),
        ),
    );
    let shadow = outline(&mut pres, 2).effects.unwrap().shadow.unwrap();
    assert_eq!(shadow.preset, None, "custom values match no preset");
    assert_eq!(shadow.color, "#C00000");
    assert_eq!(shadow.transparency, 0.25);
    assert_eq!(shadow.size_pct, 110.0);
    assert_eq!(shadow.blur_pt, 8.0);
    assert_eq!(shadow.distance_pt, 6.0);
    assert_eq!(shadow.angle_deg, 315.0);
    // A new color keeps the transparency; a preset starts over from black.
    apply(
        &mut pres,
        effects_op(&[2], json!({"shadow": {"color": "accent2"}})),
    );
    let list = effect_list(&mut pres);
    assert!(
        list.contains(r#"<a:schemeClr val="accent2"><a:alpha val="75000"/></a:schemeClr>"#),
        "{list}"
    );
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": {"preset": "innerCenter", "blurPt": 3}}),
        ),
    );
    let shadow = outline(&mut pres, 2).effects.unwrap().shadow.unwrap();
    assert_eq!((shadow.kind, shadow.blur_pt), ("inner", 3.0));
    assert_eq!(shadow.color, "#000000");
    // Options without a current shadow start from outerBottomRight.
    let mut fresh = open(&shape(2, "", ""));
    apply(
        &mut fresh,
        effects_op(&[2], json!({"shadow": {"transparency": 0.6}})),
    );
    let shadow = outline(&mut fresh, 2).effects.unwrap().shadow.unwrap();
    assert_eq!(shadow.preset, Some("outerBottomRight"));
}

#[test]
fn glow_soft_edge_and_reflection_are_written_in_schema_order() {
    let mut pres = open(&shape(2, "", ""));
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"reflection": "half4pt", "softEdge": {"sizePt": 2.5},
                   "glow": {"color": "accent2", "sizePt": 8, "transparency": 0.6},
                   "shadow": "outerTop"}),
        ),
    );
    let list = effect_list(&mut pres);
    let at = |s: &str| {
        list.find(s)
            .unwrap_or_else(|| panic!("{s} missing: {list}"))
    };
    // glow, innerShdw, outerShdw, prstShdw, reflection, softEdge.
    assert!(at("<a:glow") < at("<a:outerShdw"));
    assert!(at("<a:outerShdw") < at("<a:reflection"));
    assert!(at("<a:reflection") < at("<a:softEdge"));
    assert!(list.contains(r#"<a:glow rad="101600"><a:schemeClr val="accent2"><a:satMod val="175000"/><a:alpha val="40000"/></a:schemeClr></a:glow>"#), "{list}");
    assert!(list.contains(r#"<a:softEdge rad="31750"/>"#), "{list}");
    assert!(list.contains(r#"<a:reflection blurRad="6350" stA="50000" endA="300" endPos="55000" dist="50800" dir="5400000" sy="-100000" algn="bl" rotWithShape="0"/>"#), "{list}");
    let fx = outline(&mut pres, 2).effects.unwrap();
    assert!(!fx.inherited);
    let glow = fx.glow.unwrap();
    assert_eq!((glow.size_pt, glow.transparency), (8.0, 0.6));
    assert_eq!(fx.soft_edge.unwrap().size_pt, 2.5);
    let reflection = fx.reflection.unwrap();
    assert_eq!(reflection.preset, Some("half4pt"));
    assert_eq!(
        (
            reflection.size_pct,
            reflection.distance_pt,
            reflection.transparency
        ),
        (55.0, 4.0, 0.5)
    );
    // Reflection options adjust the current reflection.
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"reflection": {"sizePct": 80, "transparency": 0.3}}),
        ),
    );
    let reflection = outline(&mut pres, 2).effects.unwrap().reflection.unwrap();
    assert_eq!((reflection.size_pct, reflection.transparency), (80.0, 0.3));
    assert_eq!(reflection.preset, None);
    let mut reopened = assert_reopens(&mut pres);
    assert_eq!(
        outline(&mut reopened, 2).effects,
        outline(&mut pres, 2).effects
    );
}

#[test]
fn none_removes_effects_and_omitted_ones_stay() {
    let mut pres = open(&shape(2, "", ""));
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": "outerBottom", "glow": {"sizePt": 5}}),
        ),
    );
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": "none", "glow": null, "softEdge": null}),
        ),
    );
    let fx = outline(&mut pres, 2).effects.unwrap();
    assert!(fx.shadow.is_none());
    assert_eq!(fx.glow.unwrap().size_pt, 5.0, "null keeps the glow");
    apply(
        &mut pres,
        effects_op(&[2], json!({"glow": "none", "softEdge": {"sizePt": 0}})),
    );
    assert!(outline(&mut pres, 2).effects.is_none());
    assert!(
        !slide_xml(&mut pres).contains("effectLst"),
        "an emptied list that overrides nothing is removed"
    );
}

#[test]
fn theme_effects_are_reported_and_copied_before_changes() {
    let mut pres = open(&shape(2, "", THEME_SHADOW_STYLE));
    let fx = outline(&mut pres, 2).effects.unwrap();
    assert!(fx.inherited);
    let shadow = fx.shadow.unwrap();
    assert_eq!((shadow.blur_pt, shadow.distance_pt), (4.5, 1.5));
    assert_eq!(shadow.angle_deg, 90.0);
    assert_eq!(shadow.transparency, 0.37);
    // Adding a glow keeps the theme's shadow, now on the shape itself.
    apply(&mut pres, effects_op(&[2], json!({"glow": {"sizePt": 5}})));
    let fx = outline(&mut pres, 2).effects.unwrap();
    assert!(!fx.inherited);
    assert_eq!(fx.shadow.unwrap().blur_pt, 4.5);
    assert!(fx.glow.is_some());
    // Removing everything leaves an empty list that overrides the theme's.
    apply(
        &mut pres,
        effects_op(&[2], json!({"glow": "none", "shadow": "none"})),
    );
    assert!(outline(&mut pres, 2).effects.is_none());
    assert!(slide_xml(&mut pres).contains("<a:effectLst/>"));
}

#[test]
fn style_placeholder_colors_take_the_reference_color() {
    let mut pres = open(&shape(2, "", THEME_SHADOW_STYLE));
    // A theme whose effect style uses the style color (phClr).
    let theme = "/ppt/theme/theme1.xml";
    let xml = String::from_utf8(pres.package().read(theme).unwrap().into_owned()).unwrap();
    let xml = xml.replace(
        r#"<a:srgbClr val="000000"><a:alpha val="63000"/></a:srgbClr></a:outerShdw>"#,
        r#"<a:schemeClr val="phClr"><a:alpha val="63000"/></a:schemeClr></a:outerShdw>"#,
    );
    let mut package = crate::opc::Package::open(pres.save().unwrap()).unwrap();
    package.write(theme, xml.into_bytes(), None);
    let mut pres = Presentation::open(package.save().unwrap()).unwrap();
    apply(&mut pres, effects_op(&[2], json!({"glow": {"sizePt": 5}})));
    let list = effect_list(&mut pres);
    assert!(
        list.contains(r#"<a:schemeClr val="accent1"><a:alpha val="63000"/></a:schemeClr>"#),
        "{list}"
    );
    assert!(!list.contains("phClr"));
}

#[test]
fn several_shapes_change_together_and_undo_restores_them() {
    let shapes = shape(2, "", "") + &shape(3, "", "");
    let mut ed = Editor::new(open(&shapes));
    let before = ed.presentation_mut().save().unwrap();
    let result = ed
        .apply(
            &[effects_op(&[2, 3], json!({"shadow": "outerCenter"}))],
            None,
            fonts(),
        )
        .unwrap();
    assert_eq!(result.changed_slides, vec![SLIDE]);
    for id in [2, 3] {
        let shadow = outline(ed.presentation_mut(), id).effects.unwrap().shadow;
        assert_eq!(shadow.unwrap().preset, Some("outerCenter"));
    }
    ed.undo().unwrap();
    assert!(outline(ed.presentation_mut(), 2).effects.is_none());
    assert_eq!(ed.presentation_mut().save().unwrap(), before);
}

#[test]
fn bad_requests_are_refused_with_reasons() {
    let mut pres = open(&(shape(2, "", "") + TABLE));
    let err =
        |pres: &mut Presentation, op: EditOp| pres.apply(&[op], fonts()).unwrap_err().to_string();
    assert!(
        err(&mut pres, effects_op(&[9], json!({"shadow": "outerTop"}))).contains("graphic frame")
    );
    assert!(
        err(&mut pres, effects_op(&[2], json!({"shadow": "dropShadow"})))
            .contains("unknown shadow")
    );
    assert!(
        err(&mut pres, effects_op(&[2], json!({"reflection": "mirror"})))
            .contains("unknown reflection")
    );
    assert!(err(&mut pres, effects_op(&[2], json!({"glow": "accent1"}))).contains("unknown glow"));
    assert!(
        err(
            &mut pres,
            effects_op(&[2], json!({"shadow": {"transparency": 1.5}}))
        )
        .contains("out of range")
    );
    assert!(
        err(
            &mut pres,
            effects_op(
                &[2],
                json!({"shadow": {"preset": "innerTop", "sizePct": 120}})
            )
        )
        .contains("inner shadows have no size")
    );
    assert!(err(&mut pres, effects_op(&[], json!({"shadow": "none"}))).contains("at least one"));
    // A wrong option name is reported by name.
    let bad = serde_json::from_value::<EditOp>(json!({
        "op": "setShapeEffects", "slide": SLIDE, "shapes": [2], "glow": {"radius": 5}
    }))
    .unwrap_err()
    .to_string();
    assert!(bad.contains("radius"), "{bad}");
    // Nothing changed.
    assert!(!slide_xml(&mut pres).contains("effectLst"));
}

#[test]
fn text_shadow_and_glow_go_on_runs() {
    let body = r#"<a:p><a:r><a:rPr lang="en-US" sz="4000"/><a:t>WordArt</a:t></a:r></a:p>"#;
    let mut pres = open(&text_box(2, 0, 0, 5_080_000, 1_270_000, body));
    let op: EditOp = serde_json::from_value(json!({
        "op": "formatText", "slide": SLIDE, "shape": 2,
        "props": {"shadow": "outerBottomRight", "glow": {"color": "FFC000", "sizePt": 5}}
    }))
    .unwrap();
    apply(&mut pres, op);
    let xml = slide_xml(&mut pres);
    let rpr = &xml[xml.find("<a:rPr").unwrap()..xml.find("</a:rPr>").unwrap()];
    assert!(rpr.contains("<a:effectLst><a:glow"), "{rpr}");
    let layout = pres.text_layout(0, 2, None, fonts()).unwrap().unwrap();
    let fx = layout.styles[0].runs[0].effects.clone().unwrap();
    assert_eq!(fx.shadow.unwrap().preset, Some("outerBottomRight"));
    assert_eq!(fx.glow.unwrap().color, "#FFC000");
    // Removing both leaves the run without a list.
    let op = EditOp::FormatText {
        slide: SLIDE,
        shape: 2,
        cell: None,
        start: None,
        end: None,
        props: RunPatch {
            shadow: Some(EffectSpec::Preset("none".into())),
            glow: Some(EffectSpec::Preset("none".into())),
            ..RunPatch::default()
        },
    };
    apply(&mut pres, op);
    let layout = pres.text_layout(0, 2, None, fonts()).unwrap().unwrap();
    assert!(layout.styles[0].runs[0].effects.is_none());
    assert_reopens(&mut pres);
}

/// The layer effects the renderer gives a shape.
fn layer_effects(pres: &mut Presentation) -> Vec<Effect> {
    let nodes = pres.slide_display_list(0, fonts()).unwrap();
    nodes
        .iter()
        .find_map(|n| match n {
            Node::Group(g) if !g.effects.is_empty() => Some(g.effects.clone()),
            _ => None,
        })
        .unwrap_or_default()
}

#[test]
fn renderer_gets_each_effect_with_its_parameters() {
    let mut pres = open(&shape(2, "", ""));
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": "outerBottomRight", "glow": {"color": "FF0000", "sizePt": 8, "transparency": 0.5},
                   "softEdge": {"sizePt": 5}, "reflection": "full8pt"}),
        ),
    );
    let effects = layer_effects(&mut pres);
    assert_eq!(effects.len(), 4, "{effects:?}");
    let mut seen = 0;
    for e in &effects {
        match e {
            Effect::OuterShadow {
                color,
                blur,
                offset,
                ..
            } => {
                seen += 1;
                assert!((blur - 4.0).abs() < 1e-3);
                // 3 pt at 45°.
                let d = 3.0 / 2f32.sqrt();
                assert!(
                    (offset.x - d).abs() < 1e-3 && (offset.y - d).abs() < 1e-3,
                    "{offset:?}"
                );
                assert!((color.a - 0.4).abs() < 1e-3);
            }
            Effect::Glow { color, radius } => {
                seen += 1;
                assert_eq!(*radius, 8.0);
                assert!((color.r - 1.0).abs() < 1e-3 && (color.a - 0.5).abs() < 1e-3);
            }
            Effect::SoftEdge { radius } => {
                seen += 1;
                assert_eq!(*radius, 5.0);
            }
            Effect::Reflection {
                axis,
                dist,
                end_pos,
                start_alpha,
                ..
            } => {
                seen += 1;
                // The shape's bottom edge is at 200 pt.
                assert!((axis - 200.0).abs() < 1e-3);
                assert_eq!((*dist, *end_pos, *start_alpha), (8.0, 0.9, 0.5));
            }
            other => panic!("unexpected {other:?}"),
        }
    }
    assert_eq!(seen, 4);
}

/// Pixel `(x, y)` of a slide rendered at one pixel per point.
fn pixel(pres: &mut Presentation, x: u32, y: u32) -> [u8; 4] {
    let r = pres.render_slide(0, 960, fonts()).unwrap();
    let i = ((y * r.width + x) * 4) as usize;
    [
        r.pixels[i],
        r.pixels[i + 1],
        r.pixels[i + 2],
        r.pixels[i + 3],
    ]
}

#[test]
fn rendered_effects_draw_where_powerpoint_draws_them() {
    let white = [255, 255, 255, 255];
    // The shape spans (100, 100)-(300, 200) pt.
    let mut pres = open(&shape(2, "", ""));
    assert_eq!(pixel(&mut pres, 150, 215), white);
    apply(
        &mut pres,
        effects_op(&[2], json!({"shadow": "outerBottom"})),
    );
    let shaded = pixel(&mut pres, 200, 202);
    assert!(shaded[0] < 230, "an outer shadow falls below: {shaded:?}");
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": "none", "glow": {"color": "FF0000", "sizePt": 10, "transparency": 0}}),
        ),
    );
    let glow = pixel(&mut pres, 200, 204);
    assert!(
        glow[0] > 200 && glow[1] < 150,
        "a red glow surrounds it: {glow:?}"
    );
    apply(
        &mut pres,
        effects_op(&[2], json!({"glow": "none", "reflection": "fullTouching"})),
    );
    let reflected = pixel(&mut pres, 200, 205);
    assert!(
        reflected[2] > reflected[0] + 30,
        "a blue reflection: {reflected:?}"
    );
    let faded = pixel(&mut pres, 200, 299);
    assert!(faded.iter().all(|&c| c > 250), "it fades out: {faded:?}");
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"reflection": "none", "softEdge": {"sizePt": 10}}),
        ),
    );
    let edge = pixel(&mut pres, 101, 150);
    let middle = pixel(&mut pres, 200, 150);
    assert!(
        edge[0] > middle[0] + 50,
        "soft edges fade to the background: {edge:?} {middle:?}"
    );
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"softEdge": "none", "shadow": {"preset": "innerTopLeft", "transparency": 0}}),
        ),
    );
    let inner = pixel(&mut pres, 102, 102);
    assert!(
        inner[2] < middle[2] - 40,
        "an inner shadow darkens the top left: {inner:?}"
    );
}

#[test]
fn shadows_are_cast_by_the_shape_alone_and_inner_shadows_stay_inside() {
    let mut pres = open(&shape(2, "", ""));
    apply(
        &mut pres,
        effects_op(
            &[2],
            json!({"shadow": {"preset": "outerBottomRight", "transparency": 0, "blurPt": 0, "distancePt": 20},
                   "glow": {"color": "00FF00", "sizePt": 4, "transparency": 0}}),
        ),
    );
    // The shadow is offset about 14 pt right and down: it ends at x ≈ 314.
    let shadow = pixel(&mut pres, 310, 210);
    assert!(shadow.iter().take(3).all(|&c| c < 40), "{shadow:?}");
    // The glow casts no shadow of its own.
    let beyond = pixel(&mut pres, 318, 210);
    assert!(beyond.iter().all(|&c| c > 250), "{beyond:?}");

    // An inner shadow shades only the shape, not the outer shadow beside it.
    let outer = r#"<a:outerShdw blurRad="0" dist="254000" dir="0" algn="l" rotWithShape="0"><a:srgbClr val="000000"><a:alpha val="50000"/></a:srgbClr></a:outerShdw>"#;
    let inner = r#"<a:innerShdw blurRad="0" dist="127000" dir="10800000"><a:srgbClr val="000000"/></a:innerShdw>"#;
    let mut alone = open(&shape(
        2,
        &format!("<a:effectLst>{outer}</a:effectLst>"),
        "",
    ));
    let mut both = open(&shape(
        2,
        &format!("<a:effectLst>{inner}{outer}</a:effectLst>"),
        "",
    ));
    assert_eq!(pixel(&mut both, 310, 150), pixel(&mut alone, 310, 150));
    assert_eq!(pixel(&mut both, 295, 150), [0, 0, 0, 255], "shaded inside");
}