GitCorner

Code

ossartcrafteffectcraft🌐
665bfac0b339
//! Text layers: every text fixture imports with the values it was made with (the corpus
//! MANIFEST), style runs, a parented text layer with Opacity keys, the font report and hostile
//! text documents.

use crate::import::helpers::comp;
use effectcraft_aep::import::{ImportOptions, ImportResult, LossCategory, import};
use effectcraft_aep::{AepFile, Body, Chunk, parse, write};
use effectcraft_keyframe::Value;
use effectcraft_keyframe::text_doc::{Justify, TextDoc};
use effectcraft_project::{Comp, ItemKind, Layer, LayerSource, Project};
use effectcraft_time::{TICKS_PER_SECOND, Tick};

const WHITE: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
const RED: [f32; 4] = [1.0, 0.0, 0.0, 1.0];
const BLUE: [f32; 4] = [0.0, 0.0, 1.0, 1.0];

fn text_layer(c: &Comp) -> &Layer {
    c.layers.iter().find(|l| l.name == "T").expect("text layer T")
}

fn source_text(l: &Layer) -> TextDoc {
    match &l.props.prop("text/sourceText").expect("source text").value {
        Value::Text(t) => (**t).clone(),
        other => panic!("source text is {other:?}"),
    }
}

fn vec3(l: &Layer, path: &str) -> [f64; 3] {
    match l.props.prop(path).map(|p| p.value.clone()) {
        Some(Value::Vec3(v)) => v,
        other => panic!("{path}: {other:?}"),
    }
}

/// Imports a fixture and returns the text layer's Source Text, checking what every text layer
/// shares: a text layer on top of L, the text origin as anchor, Position at the comp centre, font
/// Times New Roman, no stroke.
fn imported(name: &str) -> Option<(TextDoc, ImportResult)> {
    Some({
        let (p, r) = crate::import::helpers::try_load(name)?;
        let (_, c) = comp(&p, &r, "C");
        assert_eq!(c.layers.len(), 2, "{name}");
        let t = text_layer(c);
        assert_eq!(c.layers[0].id, t.id, "{name}: T is the top layer");
        assert!(c.layers.iter().any(|l| l.name == "L"), "{name}");
        assert!(matches!(t.source, LayerSource::Text), "{name}");
        assert_eq!(vec3(t, "transform/anchor"), [0.0, 0.0, 0.0], "{name}");
        assert_eq!(vec3(t, "transform/position"), [960.0, 540.0, 0.0], "{name}");
        assert_eq!(r.report.imported.text_layers, 1, "{name}");
        let d = source_text(t);
        for run in d.runs() {
            assert_eq!(run.style.font, "TimesNewRomanPSMT", "{name}");
            assert_eq!(run.style.style, "Regular", "{name}");
            assert!(!run.style.apply_stroke, "{name}");
        }
        assert!(r.report.missing_fonts.is_empty(), "{name}: every font counts as installed by default");
        (d, r)
    })
}

/// The fixtures with nothing to lose.
fn lossless(name: &str) -> Option<TextDoc> {
    Some({
        let (d, r) = imported(name)?;
        assert!(r.report.is_lossless(), "{name}: {:?}", r.report.losses);
        d
    })
}

#[test]
fn point_text_defaults_size_and_fill() {
    // 110: "A", Times New Roman 100 px, white.
    let d = skip!(lossless("110-text-A.aep"));
    assert_eq!((d.text.as_str(), d.size, d.fill, d.box_size), ("A", 100.0, WHITE, None));
    assert_eq!((d.tracking, d.leading, d.justify), (0.0, Some(98.0), Justify::Left));
    assert!(d.is_uniform());
    assert!(!(d.faux_bold || d.faux_italic || d.all_caps || d.small_caps));
    // 113: "Hello" at 60 px, orange [1, 0.5, 0].
    let d = skip!(lossless("113-text-Hello-size60-fillorange.aep"));
    assert_eq!((d.text.as_str(), d.size, d.fill), ("Hello", 60.0, [1.0, 0.5, 0.0, 1.0]));
}

#[test]
fn two_paragraphs() {
    // 243: "A" CR "B": two paragraphs, leading 98 (the second baseline is 98 px lower in AE).
    let d = skip!(lossless("243-text-multiline-A-CR-B.aep"));
    assert_eq!(d.text, "A\rB");
    assert_eq!(d.para_count(), 2);
    assert_eq!(d.paras().iter().map(|p| p.justify).collect::<Vec<_>>(), [Justify::Left, Justify::Left]);
    assert_eq!(d.leading, Some(98.0));
}

#[test]
fn automatic_leading_imports_as_automatic_leading() {
    // 400: 387's "A" CR "B" with Auto Leading switched on (After Effects then sets the second
    // baseline 120 px below the first, 1.2 x the size 100): EffectCraft's automatic leading is the
    // same 120 % rule, so no explicit leading is set (the stored 0.01 is not used).
    let d = skip!(lossless("400-text-autoleading-on.aep"));
    assert_eq!((d.text.as_str(), d.size, d.para_count()), ("A\rB", 100.0, 2));
    assert_eq!(d.leading, None);
}

#[test]
fn etx_is_a_paragraph_break() {
    // 386: "A" U+0003 "B". After Effects lays it out exactly as 387's "A" CR "B" (two lines, two
    // paragraphs, baselines 98 px apart): it imports as 243's CR text, without a loss.
    let d = skip!(lossless("386-text-etx-A-B.aep"));
    let cr = skip!(lossless("243-text-multiline-A-CR-B.aep"));
    assert_eq!(d.text, "A\rB");
    assert_eq!(d.para_count(), 2);
    assert_eq!(d.paras().iter().map(|p| p.justify).collect::<Vec<_>>(), [Justify::Left, Justify::Left]);
    assert_eq!((d.leading, d.size), (cr.leading, cr.size));
    assert_eq!(d.runs().iter().map(|r| r.len).sum::<usize>(), 3);
}

#[test]
fn an_unnamed_text_layer_is_named_after_its_first_paragraph() {
    // 386 and 243 with the text layer's own name removed: both are named "A", as U+0003 and CR
    // both end the first paragraph.
    for name in ["386-text-etx-A-B.aep", "243-text-multiline-A-CR-B.aep"] {
        let src = fixture!(name);
        let mut file = parse(&src).unwrap();
        let mut done = false;
        visit(&mut file.chunks, &mut |c| {
            if c.is_list(b"Layr") && utf8_name(c).as_deref() == Some("T") {
                for k in c.children_mut() {
                    if k.is(b"Utf8")
                        && let Body::Data(d) = &mut k.body
                    {
                        *d = Vec::new().into();
                        done = true;
                    }
                }
            }
        });
        assert!(done, "{name}");
        let bytes = write(&file).unwrap();
        let mut p = Project::default();
        let none = |_: &str| false;
        let r = import(&mut p, &bytes, &ImportOptions::new(&none)).expect("lossless");
        let (_, c) = comp(&p, &r, "C");
        assert!(
            c.layers.iter().any(|l| l.name == "A" && matches!(l.source, LayerSource::Text)),
            "{name}: {:?}",
            c.layers.iter().map(|l| &l.name).collect::<Vec<_>>()
        );
    }
}

#[test]
fn other_control_characters_are_still_reported() {
    // A text with U+0003 and U+0007: the U+0003 becomes a paragraph break, the U+0007 is kept and reported.
    let src = fixture!("386-text-etx-A-B.aep");
    let from = utf16("A\u{3}B\r");
    let to = utf16("A\u{3}\u{7}\r");
    let at = src.windows(from.len()).position(|w| w == from.as_slice()).expect("the stored text");
    let bytes = [&src[..at], to.as_slice(), &src[at + from.len()..]].concat();
    let mut p = Project::default();
    let none = |_: &str| false;
    let r = import(&mut p, &bytes, &ImportOptions { allow_losses: true, ..ImportOptions::new(&none) }).unwrap();
    let (_, c) = comp(&p, &r, "C");
    assert_eq!(source_text(text_layer(c)).text, "A\r\u{7}");
    let loss = r.report.losses.iter().find(|l| l.category == LossCategory::TextLayers).expect("reported");
    assert!(loss.details.iter().any(|d| d.contains("U+0007") && !d.contains("U+0003")), "{:?}", loss.details);
}

#[test]
fn a_stored_text_anchor_imports_as_pixels() {
    // 385: 110 with the text layer's Anchor Point set to [10, 20], stored as pixels.
    let (p, r) = load!("385-text-anchor-10-20.aep");
    assert!(r.report.is_lossless(), "{:?}", r.report.losses);
    let (_, c) = comp(&p, &r, "C");
    let t = text_layer(c);
    assert_eq!(vec3(t, "transform/anchor"), [10.0, 20.0, 0.0]);
    assert_eq!(vec3(t, "transform/position"), [960.0, 540.0, 0.0]);
    assert_eq!(source_text(t).text, "A");
}

#[test]
fn box_text_and_justification() {
    // 245: box 400 x 200, top-left [-200, -100] in layer space, left; 246 centre; 334 right.
    for (name, justify) in [
        ("245-text-box-400x200-Hello.aep", Justify::Left),
        ("246-text-box-center-align.aep", Justify::Center),
        ("334-text-box-right-align.aep", Justify::Right),
    ] {
        let d = skip!(lossless(name));
        assert_eq!(d.text, "Hello", "{name}");
        assert_eq!((d.box_size, d.box_pos), (Some([400.0, 200.0]), [-200.0, -100.0]), "{name}");
        assert_eq!(d.justify, justify, "{name}");
    }
}

#[test]
fn character_styles() {
    // 247: tracking 100.
    assert_eq!(skip!(lossless("247-text-tracking-100.aep")).tracking, 100.0);
    // 335 / 336: faux bold / italic (the font stays Times New Roman Regular).
    let d = skip!(lossless("335-text-point-fauxbold.aep"));
    assert!(d.faux_bold && !d.faux_italic);
    let d = skip!(lossless("336-text-point-fauxitalic.aep"));
    assert!(d.faux_italic && !d.faux_bold);
    // 337 / 338: all caps / small caps.
    let d = skip!(lossless("337-text-point-allcaps.aep"));
    assert!(d.all_caps && !d.small_caps);
    let d = skip!(lossless("338-text-point-smallcaps.aep"));
    assert!(d.small_caps && !d.all_caps);
    // 339: leading 60.
    assert_eq!(skip!(lossless("339-text-point-leading60.aep")).leading, Some(60.0));
}

#[test]
fn style_runs() {
    // 248: characters 1..3 ("el") red, the rest white.
    let d = skip!(lossless("248-text-range-fill-red-1-3.aep"));
    let runs = d.runs();
    assert_eq!(runs.iter().map(|r| r.len).collect::<Vec<_>>(), [1, 2, 2]);
    assert_eq!(runs.iter().map(|r| r.style.fill).collect::<Vec<_>>(), [WHITE, RED, WHITE]);
    assert_eq!(d.substring(1..3), "el");
    // 340: "el" red; "lo" blue at 60 px. AE's last run (3 characters) includes the final CR.
    let d = skip!(lossless("340-text-range-two-styles.aep"));
    let runs = d.runs();
    assert_eq!(runs.iter().map(|r| r.len).collect::<Vec<_>>(), [1, 2, 2]);
    assert_eq!(runs.iter().map(|r| r.style.fill).collect::<Vec<_>>(), [WHITE, RED, BLUE]);
    assert_eq!(runs.iter().map(|r| r.style.size).collect::<Vec<_>>(), [100.0, 100.0, 60.0]);
    assert_eq!(d.style_at(4).size, 60.0);
}

#[test]
fn the_text_of_an_animated_layer_arrives() {
    // 114: 113 plus "Animator 1" (Opacity 0, Range Selector 1): the text arrives, and the animator
    // too (tests/text_anim.rs).
    let (d, r) = skip!(imported("114-text-animator-opacity.aep"));
    assert_eq!((d.text.as_str(), d.size, d.fill), ("Hello", 60.0, [1.0, 0.5, 0.0, 1.0]));
    assert!(r.report.is_lossless(), "{:?}", r.report.losses);
}

#[test]
fn a_text_layer_is_no_loss_and_the_import_is_not_refused() {
    let mut p = Project::default();
    let none = |_: &str| false;
    let r = import(&mut p, &fixture!("113-text-Hello-size60-fillorange.aep"), &ImportOptions::new(&none)).expect("lossless import");
    assert!(r.report.is_lossless());
}

#[test]
fn missing_fonts_are_listed_not_lost() {
    let mut p = Project::default();
    let none = |_: &str| false;
    let no_fonts = |_: &str| false;
    let opts = ImportOptions { has_font: &no_fonts, ..ImportOptions::new(&none) };
    // Losses are not allowed: a missing font must not refuse the import.
    let r = import(&mut p, &fixture!("340-text-range-two-styles.aep"), &opts).expect("a missing font is not a loss");
    // The font list has four entries; only the one the runs use is checked and listed, once.
    assert_eq!(r.report.missing_fonts, ["TimesNewRomanPSMT"]);
    let (_, c) = comp(&p, &r, "C");
    assert!(source_text(text_layer(c)).runs().iter().all(|run| run.style.font == "TimesNewRomanPSMT"));
    // A checker that knows the font lists nothing.
    let mut p = Project::default();
    let times = |f: &str| f == "TimesNewRomanPSMT";
    let r = import(&mut p, &fixture!("340-text-range-two-styles.aep"), &ImportOptions { has_font: &times, ..ImportOptions::new(&none) }).unwrap();
    assert!(r.report.missing_fonts.is_empty());
    // The dry run reports the same.
    let report = effectcraft_aep::import::analyze_with(&fixture!("110-text-A.aep"), &opts).unwrap();
    assert_eq!(report.missing_fonts, ["TimesNewRomanPSMT"]);
}

// ---------------------------------------------------------------- built cases

fn visit(chunks: &mut [Chunk<'_>], f: &mut dyn FnMut(&mut Chunk<'_>)) {
    for c in chunks {
        f(c);
        visit(c.children_mut(), f);
    }
}

fn utf8_name(c: &Chunk<'_>) -> Option<String> {
    c.children().iter().find(|k| k.is(b"Utf8")).and_then(Chunk::bytes).map(|b| String::from_utf8_lossy(b).to_string())
}

fn tdmn_is(c: &Chunk<'_>, name: &str) -> bool {
    c.is(b"tdmn") && c.bytes().is_some_and(|b| b.split(|x| *x == 0).next() == Some(name.as_bytes()))
}

/// The list that follows the `tdmn` named `name` among `children`.
fn index_after(children: &[Chunk<'_>], name: &str) -> Option<usize> {
    let at = children.iter().position(|c| tdmn_is(c, name))?;
    Some(at + 1)
}

/// The id of a layer (`ldta` bytes 0..4).
fn layer_id(c: &Chunk<'_>) -> Option<u32> {
    let b = c.children().iter().find(|k| k.is(b"ldta"))?.bytes()?;
    Some(u32::from_be_bytes(b.get(0..4)?.try_into().ok()?))
}

/// The `tdmn` + `LIST tdbs` pair of `ADBE Opacity` in the transform group of the layer `id`.
fn opacity_pair<'a>(file: &AepFile<'a>, id: u32) -> (Chunk<'a>, Chunk<'a>) {
    let mut out = None;
    let mut stack: Vec<&Chunk<'a>> = file.chunks.iter().collect();
    while let Some(c) = stack.pop() {
        if c.is_list(b"Layr") && layer_id(c) == Some(id) {
            let root = c.child_list(b"tdgp").unwrap();
            let tr = &root.children()[index_after(root.children(), "ADBE Transform Group").unwrap()];
            let i = index_after(tr.children(), "ADBE Opacity").unwrap();
            out = Some((tr.children()[i - 1].clone(), tr.children()[i].clone()));
        }
        stack.extend(c.children());
    }
    out.expect("opacity of the layer")
}

#[test]
fn parented_text_with_opacity_keys() {
    // 113's text layer T, parented to the solid L (`ldta` byte 132 as in 022), with the two
    // Opacity keys of 058 (0 % at 0 s, 100 % at 2 s) copied into T's transform group. The layer
    // ids are the cases' own (L is 0x1b in the single-case files).
    let keys_id = skip!(crate::import::helpers::comp_ids("058-key-opacity-2key.aep"))[0].2[0];
    let l_id = *skip!(crate::import::helpers::comp_ids("113-text-Hello-size60-fillorange.aep"))[0].2.last().unwrap();
    let keys_src = fixture!("058-key-opacity-2key.aep");
    let keys_file = parse(&keys_src).unwrap();
    let (tdmn, tdbs) = opacity_pair(&keys_file, keys_id);
    let (tdmn, tdbs) = (tdmn.into_owned(), tdbs.into_owned());
    let src = fixture!("113-text-Hello-size60-fillorange.aep");
    let mut file = parse(&src).unwrap();
    let mut done = (false, false);
    visit(&mut file.chunks, &mut |c| {
        if !(c.is_list(b"Layr") && utf8_name(c).as_deref() == Some("T")) {
            return;
        }
        for k in c.children_mut() {
            if k.is(b"ldta")
                && let Body::Data(d) = &mut k.body
            {
                d.to_mut()[132..136].copy_from_slice(&l_id.to_be_bytes());
                done.0 = true;
            }
            if k.is_list(b"tdgp") {
                let i = index_after(k.children(), "ADBE Transform Group").unwrap();
                if let Body::List { children, .. } = &mut k.children_mut()[i].body {
                    let end = children.iter().position(|c| tdmn_is(c, "ADBE Group End")).unwrap();
                    children.insert(end, tdbs.clone());
                    children.insert(end, tdmn.clone());
                    done.1 = true;
                }
            }
        }
    });
    assert_eq!(done, (true, true));
    let bytes = write(&file).unwrap();
    let mut p = Project::default();
    let none = |_: &str| false;
    let r = import(&mut p, &bytes, &ImportOptions::new(&none)).expect("lossless");
    let (_, c) = comp(&p, &r, "C");
    let t = text_layer(c);
    let l = c.layers.iter().find(|l| l.name == "L").unwrap();
    assert_eq!(t.parent, Some(l.id));
    let opacity = t.props.prop("transform/opacity").unwrap();
    let keys: Vec<(Tick, Value)> = opacity.keys.iter().map(|k| (k.time, k.value.clone())).collect();
    assert_eq!(keys, [(Tick::ZERO, Value::Scalar(0.0)), (Tick(2 * TICKS_PER_SECOND), Value::Scalar(100.0))]);
    assert_eq!(source_text(t).text, "Hello");
    assert_eq!(r.report.imported.keyframes, 2);
}

/// Replaces the body of the text layer's `btdk` list.
fn with_btdk(name: &str, body: &[u8]) -> Option<Vec<u8>> {
    Some({
        let src = crate::common::try_fixture(name)?;
        let mut file = parse(&src).unwrap();
        visit(&mut file.chunks, &mut |c| {
            if let Body::OpaqueList { list_type, data } = &mut c.body
                && list_type == b"btdk"
            {
                *data = body.to_vec().into();
            }
        });
        write(&file).unwrap()
    })
}

/// Imports with and without losses allowed; checks the result is usable.
fn import_hostile(bytes: &[u8]) -> Option<ImportResult> {
    let none = |_: &str| false;
    let no_fonts = |_: &str| false;
    let mut last = None;
    for allow in [false, true] {
        let mut p = Project::default();
        let opts = ImportOptions { allow_losses: allow, has_font: &no_fonts, ..ImportOptions::new(&none) };
        if let Ok(r) = import(&mut p, bytes, &opts) {
            serde_json::to_string(&p).expect("the project serialises");
            for item in p.items.values() {
                let ItemKind::Comp(c) = &item.kind else { continue };
                for l in &c.layers {
                    if let Some(Value::Text(t)) = l.props.prop("text/sourceText").map(|p| &p.value) {
                        let runs = t.runs();
                        assert_eq!(runs.iter().map(|r| r.len).sum::<usize>(), t.char_len());
                        assert!(runs.iter().all(|r| r.style.size.is_finite() && r.style.size > 0.0 && r.style.fill.iter().all(|c| c.is_finite())));
                        assert!(t.leading.is_none_or(f64::is_finite) && t.tracking.is_finite());
                        assert!(t.box_size.is_none_or(|b| b.iter().all(|v| v.is_finite() && *v >= 1.0)));
                    }
                }
            }
            last = Some(r);
        }
    }
    last
}

fn utf16(s: &str) -> Vec<u8> {
    let mut out = vec![0xfe, 0xff];
    for u in s.encode_utf16() {
        out.extend_from_slice(&u.to_be_bytes());
    }
    out
}

#[test]
fn hostile_text_documents_never_panic() {
    let real = {
        let src = fixture!("340-text-range-two-styles.aep");
        let f = parse(&src).unwrap();
        let mut body = None;
        let mut stack: Vec<&Chunk<'_>> = f.chunks.iter().collect();
        while let Some(c) = stack.pop() {
            if let Body::OpaqueList { list_type, data } = &c.body
                && list_type == b"btdk"
            {
                body = Some(data.to_vec());
            }
            stack.extend(c.children());
        }
        body.unwrap()
    };
    let hello = utf16("Hello\r");
    let at = real.windows(hello.len()).position(|w| w == hello.as_slice()).expect("the text in the body");
    let with_text = |t: &[u8]| [&real[..at], t, &real[at + hello.len()..]].concat();
    let mut cases: Vec<Vec<u8>> = vec![
        b"garbage".to_vec(),
        Vec::new(),
        b"/1 << /1 [ << /0 << /0 (".to_vec(),
        // Lone surrogates and an odd byte count.
        with_text(&[0xfe, 0xff, 0xd8, 0x00, 0x00, b'H', 0xdc, 0x00, 0x00]),
        // A huge text (2 MB of UTF-16) with the runs of a five-character one.
        with_text(&[vec![0xfe, 0xff], [0x00, b'x'].repeat(1 << 20)].concat()),
        // Control characters (U+0003 is a paragraph break, U+0007 is reported) and an empty text.
        with_text(&utf16("He\u{3}l\u{7}lo\r")),
        with_text(&utf16("")),
        // Run lengths that overflow, are negative or much longer than the text.
        real.replacen(b"/1 3 >>", b"/1 99999999999999999999999 >>"),
        real.replacen(b"/1 3 >>", b"/1 -3 >>"),
        real.replacen(b"/1 1 >>", b"/1 1000000 >>"),
        // Not-a-number sizes and colours, a font index far outside the font list.
        real.replacen(b"/1 60.0", b"/1 nan"),
        real.replacen(b"[ 1.0 0.0 0.0 1.0 ]", b"[ 1.0 inf -inf 1e309 ]"),
        real.replacen(b"/6 << /0 0 /1 100.0", b"/6 << /0 999999 /1 100.0"),
        // Unknown caps and justification codes.
        real.replacen(b"/12 0 ", b"/12 7 "),
        // Deep nesting.
        [b"/1 ".as_slice(), &b"<< /0 ".repeat(50_000), &b">> ".repeat(50_000)].concat(),
        [b"/1 ".as_slice(), &b"[ ".repeat(50_000)].concat(),
    ];
    for cut in (0..real.len()).step_by(211) {
        cases.push(real[..cut].to_vec());
    }
    for (i, body) in cases.iter().enumerate() {
        let r = import_hostile(&skip!(with_btdk("340-text-range-two-styles.aep", body)));
        assert!(r.is_some(), "case {i}: the import with losses allowed must succeed");
    }
}

/// `replacen` for byte strings (first occurrence; panics when absent so a case cannot rot).
trait ReplaceBytes {
    fn replacen(&self, from: &[u8], to: &[u8]) -> Vec<u8>;
}

impl ReplaceBytes for Vec<u8> {
    fn replacen(&self, from: &[u8], to: &[u8]) -> Vec<u8> {
        let at = self.windows(from.len()).position(|w| w == from).unwrap_or_else(|| panic!("{:?} not in the body", String::from_utf8_lossy(from)));
        [&self[..at], to, &self[at + from.len()..]].concat()
    }
}

#[test]
fn unreadable_text_keeps_the_layer() {
    let r = import_hostile(&skip!(with_btdk("113-text-Hello-size60-fillorange.aep", b"not a text document"))).unwrap();
    assert_eq!(r.report.imported.text_layers, 1);
    assert_eq!(r.report.count(LossCategory::DamagedData), 1, "{:?}", r.report.losses);
}

#[test]
fn superscript_and_subscript_import_as_such() {
    use effectcraft_keyframe::text_doc::BaselineOption;
    // 526: the corpus' default character state is superscript; 527 normal; 528 subscript.
    for (name, want) in [
        ("526-text-point-HHHH-default.aep", BaselineOption::Superscript),
        ("527-text-point-HHHH-baseline-normal.aep", BaselineOption::Normal),
        ("528-text-point-HHHH-baseline-subscript.aep", BaselineOption::Subscript),
        ("243-text-multiline-A-CR-B.aep", BaselineOption::Superscript),
    ] {
        let doc = skip!(lossless(name));
        assert_eq!(doc.style_at(0).baseline, want, "{name}");
    }
}

#[test]
fn a_wrapping_box_text_keeps_its_box() {
    let doc = skip!(lossless("517-text-box-600x400-wrap.aep"));
    assert_eq!(doc.text, "The quick brown fox jumps over the lazy dog and keeps running far away");
    assert_eq!((doc.box_size, doc.box_pos), (Some([600.0, 400.0]), [-300.0, -200.0]));
    assert_eq!(doc.style_at(0).size, 100.0);
}