Both composers append the marker layer as the root's last child, so a root visibility="hidden" whose children set visible back drew the drawing without a marker (0 marker pixels in Chromium and Firefox, PDF and canvas). The reader refuses any root visibility but visible (root_visibility); cleaning, verdict, preview, PDF gate and both composers answer it.
519 lines
21 KiB
Rust
519 lines
21 KiB
Rust
//! R4.6: the incremental export session (plan §B.1.4, OD-2). Source: the TypeScript
|
|
//! export's behaviours the session reproduces step by step (`packages/pdf/src/export.ts`,
|
|
//! `render/observationPage.ts`, `branding.ts`, `svg/view.ts`): the raster requests (SVG
|
|
//! logos, then each observation's views, main first), the warning order (a raster that
|
|
//! fails before any embed, then a PNG `embedPng` refused, in view order), the state
|
|
//! machine's closed refusals, and the file: driven key by key it is the one `export_pdf`
|
|
//! gives (the frozen R4 digests). `rasterSizeOf` against the O4 oracle.
|
|
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
|
|
|
|
mod common;
|
|
|
|
use std::collections::HashSet;
|
|
|
|
use common::r4::{r4_oracle, repo_root, sha256_hex};
|
|
use faunosteo_core::anatomy::compose::{asset_id_of_view, compose_highlight};
|
|
use faunosteo_core::anatomy::svg::tree::parse_svg;
|
|
use faunosteo_core::anatomy::svg::{Element, read_svg, serialize::serialize};
|
|
use faunosteo_core::domain::js::parse_json;
|
|
use faunosteo_core::pdf::read::probe::{ProbeLimits, read_attached_document};
|
|
use faunosteo_core::pdf::write::export::export_pdf;
|
|
use faunosteo_core::pdf::write::input::{
|
|
ExportError, ExportErrorKind, ExportInput, ExportWarning, LogoSlot, Rasters,
|
|
};
|
|
use faunosteo_core::pdf::write::session::{
|
|
ExportSession, ExportStep, SessionError, SessionRefusal, keyed,
|
|
};
|
|
use faunosteo_core::pdf::write::views::{RASTER_WIDTH_PX, RasterRequest, raster_size_of};
|
|
use serde_json::{Value, json};
|
|
|
|
const TWO_BY_ONE_PNG: &str = "iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAIAAAB7QOjdAAAAD0lEQVR4nGPYEWX///9/AA0PBE/1T7nxAAAAAElFTkSuQmCC";
|
|
|
|
fn base64(text: &str) -> Vec<u8> {
|
|
faunosteo_core::pdf::write::layout::png::base64_bytes(text).unwrap()
|
|
}
|
|
|
|
fn fixture(path: &str) -> Vec<u8> {
|
|
std::fs::read(repo_root().join("apps/app/tests/fixtures").join(path)).unwrap()
|
|
}
|
|
|
|
fn demo_input() -> ExportInput {
|
|
let pdf = fixture("pdf/r3/demo.fr.logos.pdf");
|
|
let located = read_attached_document(&pdf, ProbeLimits::UNBOUNDED).unwrap();
|
|
let envelope: Value = parse_json(&located.text).unwrap();
|
|
serde_json::from_value(json!({
|
|
"report": envelope["report"],
|
|
"sheetSnapshot": envelope["sheetSnapshot"],
|
|
"branding": envelope["branding"],
|
|
"labels": envelope["labels"],
|
|
"locale": envelope["locale"],
|
|
"exportedAt": envelope["exportedAt"],
|
|
}))
|
|
.unwrap()
|
|
}
|
|
|
|
fn stub_rasters(input: &ExportInput, png: &[u8]) -> Rasters {
|
|
let mut rasters = Rasters {
|
|
header_logo: Some(png.to_vec()),
|
|
footer_logo: Some(png.to_vec()),
|
|
powered_by: Some(png.to_vec()),
|
|
partner: Some(png.to_vec()),
|
|
views: Default::default(),
|
|
};
|
|
for observation in &input.report.observations {
|
|
for zone in &observation.zones {
|
|
rasters
|
|
.views
|
|
.entry((observation.id.clone(), zone.view_id.clone()))
|
|
.or_insert_with(|| png.to_vec());
|
|
}
|
|
}
|
|
rasters
|
|
}
|
|
|
|
fn refusal(error: SessionError) -> SessionRefusal {
|
|
match error {
|
|
SessionError::Refused(refusal) => refusal,
|
|
SessionError::Export(error) => panic!("export error {error:?}"),
|
|
}
|
|
}
|
|
|
|
fn requests(step: ExportStep) -> Vec<RasterRequest> {
|
|
match step {
|
|
ExportStep::Rasters { requests } => requests,
|
|
ExportStep::Done => panic!("done too early"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn raster_size_of_reproduces_the_o4_cases() {
|
|
let oracle = r4_oracle("text.json");
|
|
let cases = oracle["rasterSizeOf"]["cases"].as_array().unwrap();
|
|
assert!(cases.len() > 40, "{} cases", cases.len());
|
|
for case in cases {
|
|
let row = case.as_array().unwrap();
|
|
let input = row[0].as_str();
|
|
let expected = (
|
|
row[1].as_u64().unwrap() as u32,
|
|
row[2].as_u64().unwrap() as u32,
|
|
);
|
|
assert_eq!(raster_size_of(input), expected, "{:?}", row[0]);
|
|
}
|
|
assert_eq!(raster_size_of(None).0, RASTER_WIDTH_PX);
|
|
}
|
|
|
|
/// The branding step asks for the SVG logos only (the demo branding: the partner), each
|
|
/// observation step for its views with the main view first; every request's SVG is the
|
|
/// R3 composition of that view and its size the composed root's viewBox rule.
|
|
#[test]
|
|
fn the_requests_are_the_svg_logos_then_each_observations_views_main_first() {
|
|
let input = demo_input();
|
|
let report = input.report.clone();
|
|
let snapshot: faunosteo_core::domain::archive::SheetSnapshot =
|
|
serde_json::from_value(input.sheet_snapshot.clone()).unwrap();
|
|
let mut session = ExportSession::new(input).unwrap();
|
|
let branding = requests(session.next_step().unwrap());
|
|
assert_eq!(
|
|
branding.iter().map(|r| r.key.as_str()).collect::<Vec<_>>(),
|
|
vec!["logo:partner"]
|
|
);
|
|
assert!(branding[0].svg.starts_with("<svg"));
|
|
assert_eq!(branding[0].width_px, RASTER_WIDTH_PX);
|
|
assert_eq!(
|
|
(branding[0].width_px, branding[0].height_px),
|
|
raster_size_of(read_svg(&branding[0].svg).unwrap().root.attr("viewBox"))
|
|
);
|
|
session
|
|
.add_raster("logo:partner", &base64(TWO_BY_ONE_PNG))
|
|
.unwrap();
|
|
let document = &snapshot.document;
|
|
let main = document.views.iter().find(|v| v.is_main()).unwrap().id();
|
|
for observation in &report.observations {
|
|
let batch = requests(session.next_step().unwrap());
|
|
let mut seen = Vec::new();
|
|
for zone in &observation.zones {
|
|
if !seen.contains(&zone.view_id.as_str()) {
|
|
seen.push(&zone.view_id);
|
|
}
|
|
}
|
|
let expected_order: Vec<String> = seen
|
|
.iter()
|
|
.filter(|id| **id == main)
|
|
.chain(seen.iter().filter(|id| **id != main))
|
|
.map(|id| format!("view:{}:{id}", observation.id))
|
|
.collect();
|
|
assert_eq!(
|
|
batch.iter().map(|r| r.key.clone()).collect::<Vec<_>>(),
|
|
expected_order,
|
|
"{}",
|
|
observation.id
|
|
);
|
|
for request in &batch {
|
|
let view_id = request.key.rsplit(':').next().unwrap();
|
|
let ids: HashSet<&str> = observation
|
|
.zones
|
|
.iter()
|
|
.filter(|z| z.view_id == view_id)
|
|
.map(|z| z.annotation_id.as_str())
|
|
.collect();
|
|
let asset_id = asset_id_of_view(document, view_id).unwrap();
|
|
let asset = snapshot
|
|
.assets
|
|
.iter()
|
|
.find(|a| a.svg_asset_id == asset_id)
|
|
.unwrap();
|
|
let root = read_svg(&asset.svg).unwrap().root;
|
|
let composed =
|
|
compose_highlight(document, view_id, root, &ids, view_id == main).unwrap();
|
|
assert_eq!(request.svg, serialize(&composed), "{}", request.key);
|
|
assert_eq!(
|
|
(request.width_px, request.height_px),
|
|
raster_size_of(composed.attr("viewBox")),
|
|
"{}",
|
|
request.key
|
|
);
|
|
session
|
|
.add_raster(&request.key, &base64(TWO_BY_ONE_PNG))
|
|
.unwrap();
|
|
}
|
|
}
|
|
assert_eq!(session.next_step().unwrap(), ExportStep::Done);
|
|
session.finish().unwrap();
|
|
let pdf = session.take_part().unwrap();
|
|
assert!(pdf.starts_with(b"%PDF-1.7"));
|
|
assert!(session.warnings().is_empty());
|
|
}
|
|
|
|
/// Driven key by key, the session writes the bytes `export_pdf` writes (the frozen digest),
|
|
/// and the file grows as the rasters arrive (nothing waits for `finish`).
|
|
#[test]
|
|
fn the_session_gives_the_one_shot_bytes_and_grows_as_rasters_arrive() {
|
|
let input = demo_input();
|
|
let rasters = stub_rasters(&input, &base64(TWO_BY_ONE_PNG));
|
|
let one_shot = export_pdf(input.clone(), &rasters).unwrap();
|
|
let frozen = std::fs::read_to_string(
|
|
repo_root().join("apps/app/tests/fixtures/goldens/r4/pdf.demo.fr.logos.sha256"),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(sha256_hex(&one_shot.pdf), frozen.trim());
|
|
let map = keyed(&rasters);
|
|
let mut session = ExportSession::new(input).unwrap();
|
|
let opened = session.written();
|
|
assert!(opened > 0);
|
|
let mut grew_during_batches = false;
|
|
while let ExportStep::Rasters { requests } = session.next_step().unwrap() {
|
|
for request in requests {
|
|
let before = session.written();
|
|
session.add_raster(&request.key, map[&request.key]).unwrap();
|
|
if request.key.starts_with("view:") {
|
|
assert!(session.written() > before, "{}", request.key);
|
|
grew_during_batches = true;
|
|
}
|
|
}
|
|
}
|
|
assert!(grew_during_batches);
|
|
session.finish().unwrap();
|
|
// The parts, each under a few MiB with the stub rasters, moved out one by one.
|
|
let parts = session.parts_left();
|
|
assert!(parts >= 1);
|
|
let mut pdf = Vec::new();
|
|
while let Some(part) = session.take_part() {
|
|
assert!(!part.is_empty());
|
|
pdf.extend_from_slice(&part);
|
|
}
|
|
assert_eq!(session.take_part(), None);
|
|
assert_eq!(session.written(), pdf.len());
|
|
assert_eq!(pdf, one_shot.pdf);
|
|
assert_eq!(session.envelope(), one_shot.envelope);
|
|
assert_eq!(session.warnings(), one_shot.warnings.as_slice());
|
|
}
|
|
|
|
#[test]
|
|
fn the_state_machine_refuses_with_closed_kinds_and_never_traps() {
|
|
let input = demo_input();
|
|
let png = base64(TWO_BY_ONE_PNG);
|
|
let mut session = ExportSession::new(input).unwrap();
|
|
assert_eq!(
|
|
refusal(session.add_raster("logo:partner", &png).unwrap_err()),
|
|
SessionRefusal::UnknownKey,
|
|
"before the first next()"
|
|
);
|
|
assert_eq!(
|
|
refusal(session.finish().unwrap_err()),
|
|
SessionRefusal::OutOfOrder
|
|
);
|
|
let branding = requests(session.next_step().unwrap());
|
|
assert_eq!(
|
|
refusal(session.next_step().unwrap_err()),
|
|
SessionRefusal::OutOfOrder,
|
|
"next() with a key unanswered"
|
|
);
|
|
assert_eq!(
|
|
refusal(session.add_raster("logo:headerLogo", &png).unwrap_err()),
|
|
SessionRefusal::UnknownKey
|
|
);
|
|
assert_eq!(
|
|
refusal(session.add_raster("view:x:y", &png).unwrap_err()),
|
|
SessionRefusal::UnknownKey
|
|
);
|
|
session.add_raster(&branding[0].key, &png).unwrap();
|
|
assert_eq!(
|
|
refusal(session.add_raster(&branding[0].key, &png).unwrap_err()),
|
|
SessionRefusal::DuplicateKey
|
|
);
|
|
assert_eq!(
|
|
refusal(session.raster_failed(&branding[0].key).unwrap_err()),
|
|
SessionRefusal::DuplicateKey
|
|
);
|
|
while let ExportStep::Rasters { requests } = session.next_step().unwrap() {
|
|
for request in requests {
|
|
// Garbage, an empty slice and a truncated PNG: a warning each, never a trap.
|
|
let bytes: &[u8] = match request.key.len() % 3 {
|
|
0 => b"not a png",
|
|
1 => b"",
|
|
_ => &png[..20],
|
|
};
|
|
session.add_raster(&request.key, bytes).unwrap();
|
|
}
|
|
}
|
|
assert_eq!(session.next_step().unwrap(), ExportStep::Done);
|
|
session.finish().unwrap();
|
|
assert!(session.take_part().unwrap().starts_with(b"%PDF-1.7"));
|
|
assert_eq!(
|
|
refusal(session.finish().unwrap_err()),
|
|
SessionRefusal::OutOfOrder,
|
|
"a second finish()"
|
|
);
|
|
assert_eq!(
|
|
refusal(session.next_step().unwrap_err()),
|
|
SessionRefusal::OutOfOrder
|
|
);
|
|
assert_eq!(
|
|
refusal(session.add_raster("logo:partner", &png).unwrap_err()),
|
|
SessionRefusal::OutOfOrder
|
|
);
|
|
let views: usize = session
|
|
.warnings()
|
|
.iter()
|
|
.filter(|w| matches!(w, ExportWarning::ViewRasterFailed { .. }))
|
|
.count();
|
|
assert!(views > 0);
|
|
}
|
|
|
|
/// The warning order of the TypeScript: for an observation, the rasters that failed
|
|
/// (`raster_failed`, in the order the driver reports them) come before the PNGs the
|
|
/// decoder refused (in view order, as `embedPng` ran); a logo warning sits where its slot
|
|
/// embeds, whatever the order its raster arrived in.
|
|
#[test]
|
|
fn warnings_keep_the_typescript_order() {
|
|
let input = demo_input();
|
|
let png = base64(TWO_BY_ONE_PNG);
|
|
let two_views = input
|
|
.report
|
|
.observations
|
|
.iter()
|
|
.find(|o| {
|
|
o.zones
|
|
.iter()
|
|
.map(|z| &z.view_id)
|
|
.collect::<HashSet<_>>()
|
|
.len()
|
|
>= 2
|
|
})
|
|
.map(|o| o.id.clone())
|
|
.expect("an observation with two views");
|
|
let mut session = ExportSession::new(input).unwrap();
|
|
let branding = requests(session.next_step().unwrap());
|
|
session.raster_failed(&branding[0].key).unwrap();
|
|
let mut expected = vec![ExportWarning::LogoFailed {
|
|
slot: LogoSlot::Partner,
|
|
}];
|
|
while let ExportStep::Rasters { requests } = session.next_step().unwrap() {
|
|
let key_of = |r: &RasterRequest| r.key.clone();
|
|
let observation_id = requests[0].key.split(':').nth(1).unwrap().to_owned();
|
|
let view_of = |r: &RasterRequest| r.key.rsplit(':').next().unwrap().to_owned();
|
|
if observation_id == two_views {
|
|
// The driver reports the second view's failure first (it rejected first), then
|
|
// answers the batch in request order with a PNG the decoder refuses.
|
|
session.raster_failed(&key_of(&requests[1])).unwrap();
|
|
expected.push(ExportWarning::ViewRasterFailed {
|
|
observation_id: observation_id.clone(),
|
|
view_id: view_of(&requests[1]),
|
|
});
|
|
session.add_raster(&key_of(&requests[0]), b"bad").unwrap();
|
|
expected.push(ExportWarning::ViewRasterFailed {
|
|
observation_id: observation_id.clone(),
|
|
view_id: view_of(&requests[0]),
|
|
});
|
|
for request in &requests[2..] {
|
|
session.add_raster(&key_of(request), &png).unwrap();
|
|
}
|
|
} else {
|
|
for request in &requests {
|
|
session.add_raster(&key_of(request), &png).unwrap();
|
|
}
|
|
}
|
|
}
|
|
session.finish().unwrap();
|
|
assert_eq!(session.warnings(), expected.as_slice());
|
|
}
|
|
|
|
/// `export_pdf` answers the session from its map: an absent view is `raster_failed`, an
|
|
/// absent SVG logo too (its slot warns), a PNG asset logo never asks for a raster.
|
|
#[test]
|
|
fn the_one_shot_driver_reports_absent_rasters_as_failed() {
|
|
let input = demo_input();
|
|
let png = base64(TWO_BY_ONE_PNG);
|
|
let mut rasters = stub_rasters(&input, &png);
|
|
rasters.partner = None;
|
|
rasters.header_logo = None;
|
|
let first = rasters.views.keys().min().cloned().unwrap();
|
|
rasters.views.remove(&first);
|
|
let result = export_pdf(input, &rasters).unwrap();
|
|
assert_eq!(
|
|
result.warnings,
|
|
vec![
|
|
ExportWarning::LogoFailed {
|
|
slot: LogoSlot::Partner
|
|
},
|
|
ExportWarning::ViewRasterFailed {
|
|
observation_id: first.0,
|
|
view_id: first.1,
|
|
},
|
|
]
|
|
);
|
|
}
|
|
|
|
/// The demo export's input as JSON, before it is typed.
|
|
fn demo_value() -> Value {
|
|
let pdf = fixture("pdf/r3/demo.fr.logos.pdf");
|
|
let located = read_attached_document(&pdf, ProbeLimits::UNBOUNDED).unwrap();
|
|
let envelope: Value = parse_json(&located.text).unwrap();
|
|
json!({
|
|
"report": envelope["report"],
|
|
"sheetSnapshot": envelope["sheetSnapshot"],
|
|
"branding": envelope["branding"],
|
|
"labels": envelope["labels"],
|
|
"locale": envelope["locale"],
|
|
"exportedAt": envelope["exportedAt"],
|
|
})
|
|
}
|
|
|
|
/// The demo export's snapshot with `edit` applied to its first drawing.
|
|
fn export_with_drawing(edit: impl Fn(&str) -> String) -> Result<ExportSession, ExportError> {
|
|
let mut input = demo_value();
|
|
let svg = input["sheetSnapshot"]["assets"][0]["svg"].as_str().unwrap();
|
|
input["sheetSnapshot"]["assets"][0]["svg"] = json!(edit(svg));
|
|
ExportSession::new(serde_json::from_value(input).unwrap())
|
|
}
|
|
|
|
/// The first drawing with `body` written right after its root's opening tag.
|
|
fn inject(body: &'static str) -> impl Fn(&str) -> String {
|
|
move |svg: &str| {
|
|
let open = svg.find("<svg").unwrap();
|
|
let end = open + svg[open..].find('>').unwrap() + 1;
|
|
format!("{}{body}{}", &svg[..end], &svg[end..])
|
|
}
|
|
}
|
|
|
|
/// V1-2.2 owner brief 2026-10-30 (reserved ids, `tests/svg_reserved_ids.rs`): a snapshot
|
|
/// drawing holding the reserved id is refused at the gate (`snapshot_invalid`, `asset
|
|
/// reserved_id`), never composed; the demo export's views carry the engine's halo filter once,
|
|
/// and every highlighted marker names it.
|
|
#[test]
|
|
fn the_pdf_refuses_a_reserved_id_and_keeps_its_own_halo() {
|
|
for body in [
|
|
"<filter id=\"osteo-halo\"><feColorMatrix type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\"/></filter>",
|
|
"<g id=\"osteo-halo\"/><defs/>",
|
|
"<g id=\"Osteo-Halo\"/>",
|
|
] {
|
|
match export_with_drawing(inject(body)) {
|
|
Err(error) => {
|
|
assert_eq!(error.kind, ExportErrorKind::SnapshotInvalid, "{body}");
|
|
assert_eq!(error.detail, "asset reserved_id", "{body}");
|
|
}
|
|
Ok(_) => panic!("{body}: composed"),
|
|
}
|
|
}
|
|
|
|
let mut session = export_with_drawing(str::to_owned).unwrap();
|
|
let png = base64(TWO_BY_ONE_PNG);
|
|
let mut haloed_views = 0;
|
|
while let ExportStep::Rasters { requests } = session.next_step().unwrap() {
|
|
for request in requests {
|
|
let root = parse_svg(&request.svg).unwrap();
|
|
let mut halos = Vec::new();
|
|
holders(&root, "osteo-halo", &mut halos);
|
|
if request.key.starts_with("view:") && request.svg.contains("url(#osteo-halo)") {
|
|
haloed_views += 1;
|
|
assert_eq!(halos.len(), 1, "{}", request.key);
|
|
assert_eq!(halos[0].qname, "filter", "{}", request.key);
|
|
assert_eq!(
|
|
serialize(halos[0]),
|
|
concat!(
|
|
"<filter xmlns=\"http://www.w3.org/2000/svg\" id=\"osteo-halo\" x=\"-100%\" y=\"-100%\" width=\"300%\" ",
|
|
"height=\"300%\" filterUnits=\"userSpaceOnUse\">",
|
|
"<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"18\" result=\"haloWide\"/>",
|
|
"<feGaussianBlur in=\"SourceGraphic\" stdDeviation=\"8\" result=\"haloTight\"/>",
|
|
"<feMerge><feMergeNode in=\"haloWide\"/><feMergeNode in=\"haloWide\"/>",
|
|
"<feMergeNode in=\"haloWide\"/><feMergeNode in=\"haloTight\"/>",
|
|
"<feMergeNode in=\"haloTight\"/><feMergeNode in=\"SourceGraphic\"/></feMerge>",
|
|
"</filter>"
|
|
),
|
|
"{}",
|
|
request.key
|
|
);
|
|
let layer = root.element_children().last().unwrap();
|
|
assert!(layer.element_children().count() > 0, "{}", request.key);
|
|
for marker in layer.element_children() {
|
|
assert_eq!(marker.attr("filter"), Some("url(#osteo-halo)"));
|
|
assert_eq!(marker.attr("fill"), Some("#b85a3f"));
|
|
}
|
|
} else {
|
|
assert!(halos.is_empty(), "{}", request.key);
|
|
}
|
|
session.add_raster(&request.key, &png).unwrap();
|
|
}
|
|
}
|
|
assert!(haloed_views > 0);
|
|
session.finish().unwrap();
|
|
assert!(session.take_part().unwrap().starts_with(b"%PDF-1.7"));
|
|
assert!(session.warnings().is_empty());
|
|
}
|
|
|
|
/// Every element holding `id`, in document order.
|
|
fn holders<'a>(element: &'a Element, id: &str, out: &mut Vec<&'a Element>) {
|
|
if element.attr("id") == Some(id) {
|
|
out.push(element);
|
|
}
|
|
for child in element.element_children() {
|
|
holders(child, id, out);
|
|
}
|
|
}
|
|
|
|
/// V1-2.2 owner brief 2026-10-30 (root visibility, `tests/svg_root_visibility.rs`): a snapshot
|
|
/// drawing whose root is not `visible`, its children set `visible` back, is refused at the gate
|
|
/// (`snapshot_invalid`, `asset root_visibility`): its markers would not show in the PDF.
|
|
#[test]
|
|
fn the_pdf_refuses_a_drawing_whose_root_hides_the_markers() {
|
|
for value in ["hidden", "collapse", "HIDDEN", "inherit"] {
|
|
let edit = move |svg: &str| {
|
|
let tagged = svg.replacen("<svg", &format!("<svg visibility=\"{value}\""), 1);
|
|
let open = tagged.find("<svg").unwrap();
|
|
let end = open + tagged[open..].find('>').unwrap() + 1;
|
|
format!(
|
|
"{}<g visibility=\"visible\">{}</g></svg>",
|
|
&tagged[..end],
|
|
tagged[end..].trim_end().trim_end_matches("</svg>")
|
|
)
|
|
};
|
|
match export_with_drawing(edit) {
|
|
Err(error) => {
|
|
assert_eq!(error.kind, ExportErrorKind::SnapshotInvalid, "{value}");
|
|
assert_eq!(error.detail, "asset root_visibility", "{value}");
|
|
}
|
|
Ok(_) => panic!("{value}: composed"),
|
|
}
|
|
}
|
|
}
|