pauljd/pdfcraft
1
0
Fork 0
mirror of https://github.com/storytold/pdfcraft.git synced 2026-11-09 20:04:37 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
f996aef12ff7dc2d48dc40f4176448287c2efdcf
pdfcraft/crates/edit/tests/flatten_optional_content.rs
T

473 lines
24 KiB
Rust
Raw Blame History

//! Optional-content regression fixtures for issue #3213.
use std::sync::Arc;
use pdfcraft_cos::{Document, ObjRef, Object, SaveOptions, write_incremental};
/// Build a single-page PDF fixture with a hidden OCG (`4 0 R`), a shown OCG (`5 0 R`),
/// a form appearance (`7 0 R`), an annotation (`8 0 R`), and an OCMD (`9 0 R`).
fn fixture(membership: &str, flags: i64, appearance_membership: &str) -> Document {
let ink = "1 0 0 rg 0 0 100 50 re f";
let objects = [
"<< /Type /Catalog /Pages 2 0 R /OCProperties << /OCGs [4 0 R 5 0 R] /D << /OFF [4 0 R] /ON [5 0 R] /Order [4 0 R 5 0 R] >> >> >>".to_string(),
"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into(),
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Resources << /Properties << /Existing 5 0 R /PCFlOC0 5 0 R /Private (keep) >> >> /Contents 6 0 R /Annots [8 0 R] >>".into(),
"<< /Type /OCG /Name (Hidden layer) /Private (keep layer) >>".into(),
"<< /Type /OCG /Name (Shown layer) >>".into(),
"<< /Length 0 >>\nstream\n\nendstream".into(),
format!("<< /Type /XObject /Subtype /Form /BBox [0 0 100 50] {appearance_membership} /Length {} >>\nstream\n{ink}\nendstream", ink.len()),
format!("<< /Type /Annot /Subtype /Square /Rect [50 50 150 100] /C [1 0 0] /AP << /N 7 0 R >> /F {flags} {membership} /Private (keep annotation) >>"),
"<< /Type /OCMD /OCGs [4 0 R] /P /AllOn /Private (keep membership) >>".into(),
];
let mut out = b"%PDF-1.7\n".to_vec();
let mut offsets = Vec::new();
for (i, object) in objects.iter().enumerate() {
offsets.push(out.len());
out.extend_from_slice(format!("{} 0 obj\n{object}\nendobj\n", i + 1).as_bytes());
}
let xref = out.len();
out.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).as_bytes());
for offset in offsets {
out.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
out.extend_from_slice(format!("trailer\n<< /Root 1 0 R /Size {} >>\nstartxref\n{xref}\n%%EOF\n", objects.len() + 1).as_bytes());
Document::open(Arc::new(out)).unwrap()
}
/// Serialize `doc` using an incremental save.
fn saved(doc: &Document) -> Vec<u8> {
write_incremental(doc, &SaveOptions::default()).unwrap()
}
/// Optionally export test PDF bytes when `PDFCRAFT_3213_ARTIFACTS` is set.
fn export(name: &str, stage: &str, bytes: &[u8]) {
if let Some(directory) = std::env::var_os("PDFCRAFT_3213_ARTIFACTS") {
std::fs::write(std::path::Path::new(&directory).join(format!("{name}-{stage}.pdf")), bytes).unwrap();
}
}
/// Verify that transferable optional-content memberships are bound to flattened appearances
/// after saving and reopening, while hidden-flag annotations remain untouched.
#[test]
fn flatten_keeps_annotation_optional_content_after_save_and_reopen() {
let mut lost = Vec::new();
for (name, membership, flags, ap_oc) in [
("off", "/OC 4 0 R", 4, ""),
("on", "/OC 5 0 R", 4, ""),
("ocmd", "/OC 9 0 R", 4, ""),
("independent_ap", "/OC 4 0 R", 4, "/OC 5 0 R"),
("direct_ocmd", "/OC << /Type /OCMD /OCGs [4 0 R] /P /AllOn /Private (keep inline) >>", 4, ""),
("ocmd_ve", "/OC << /Type /OCMD /VE [/And 4 0 R [/Not 5 0 R]] /Private (keep expression) >>", 4, ""),
("visible", "", 4, ""),
("hidden_flag", "", 2, ""),
] {
let mut doc = fixture(membership, flags, ap_oc);
let original_appearance = (*doc.get(ObjRef::new(7, 0))).clone();
let expected_membership = doc.get(pdfcraft_cos::ObjRef::new(8, 0)).as_dict().unwrap().get(b"OC").cloned();
export(name, "before", &saved(&doc));
let count = pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap();
let bytes = saved(&doc);
export(name, "flat", &bytes);
let reopened = Document::open(Arc::new(bytes)).unwrap();
assert_eq!(count, usize::from(flags != 2), "{name}");
let paints = paint_memberships(&reopened);
if flags != 2 && paints != vec![(ObjRef::new(7, 0), expected_membership)] {
lost.push(name);
}
assert_eq!(*reopened.get(ObjRef::new(7, 0)), original_appearance, "{name}: preserve appearance");
}
assert!(lost.is_empty(), "flattened paint loses its original membership: {lost:?}");
}
/// Verify that multiple annotations sharing one appearance stream keep separate memberships
/// without mutating the shared appearance stream itself.
#[test]
fn flatten_shared_appearance_keeps_separate_memberships_and_original_stream() {
let mut doc = fixture("/OC 4 0 R", 4, "");
let first = ObjRef::new(8, 0);
let ap = ObjRef::new(7, 0);
let original_ap = (*doc.get(ap)).clone();
let mut second = doc.get(first).as_dict().unwrap().clone();
second.set(b"OC".to_vec(), Object::Ref(ObjRef::new(5, 0)));
second.set(b"Rect".to_vec(), Object::Array([50, 120, 150, 170].into_iter().map(Object::Int).collect()));
let second = doc.add(Object::Dict(second));
let mut plain = doc.get(first).as_dict().unwrap().clone();
plain.remove(b"OC");
plain.set(b"Rect".to_vec(), Object::Array([0, 0, 20, 10].into_iter().map(Object::Int).collect()));
let plain = doc.add(Object::Dict(plain));
doc.update_dict(ObjRef::new(3, 0), |page| {
page.set(b"Annots".to_vec(), Object::Array(vec![Object::Ref(first), Object::Ref(second), Object::Ref(plain)]))
})
.unwrap();
export("shared", "before", &saved(&doc));
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 3);
let bytes = saved(&doc);
export("shared", "flat", &bytes);
let doc = Document::open(Arc::new(bytes)).unwrap();
assert_eq!(*doc.get(ap), original_ap, "a shared appearance must never acquire either annotation's /OC");
assert_eq!(paint_memberships(&doc), vec![(ap, Some(Object::Ref(ObjRef::new(4, 0)))), (ap, Some(Object::Ref(ObjRef::new(5, 0)))), (ap, None)]);
}
/// Associate each `Do` invocation with its active `/OC` marked-content block.
fn paint_memberships(doc: &Document) -> Vec<(ObjRef, Option<Object>)> {
let page = pdfcraft_model::pages(doc).remove(0);
let resources = doc.resolve(page.dict.get(b"Resources").unwrap());
let resources = resources.as_dict().unwrap();
let properties = resources.get(b"Properties").map(|p| doc.resolve(p));
let xobjects = resources.get(b"XObject").map(|p| doc.resolve(p));
let content = doc.resolve(page.dict.get(b"Contents").unwrap());
let streams = match &*content {
Object::Array(list) => list.clone(),
_ => vec![page.dict.get(b"Contents").unwrap().clone()],
};
let mut contexts = Vec::new();
let mut paints = Vec::new();
for stream in streams {
let resolved = doc.resolve(&stream);
let Object::Stream(stream) = &*resolved else { panic!("content stream") };
let parsed = pdfcraft_content::parse(&stream.decoded().unwrap());
assert_eq!(parsed.skipped, 0);
for op in parsed.ops {
if op.is("BDC") {
let membership = if op.name(0) == Some(b"OC") {
Some(properties.as_ref().unwrap().as_dict().unwrap().get(op.name(1).unwrap()).unwrap().clone())
} else {
None
};
contexts.push(membership);
} else if op.is("BMC") {
contexts.push(None);
} else if op.is("EMC") {
assert!(contexts.pop().is_some(), "balanced marked content");
} else if op.is("Do") {
let reference = xobjects.as_ref().unwrap().as_dict().unwrap().reference(op.name(0).unwrap()).unwrap();
paints.push((reference, contexts.iter().rev().find_map(Clone::clone)));
}
}
}
assert!(contexts.is_empty(), "every optional-content block must close");
paints
}
/// Verify that unsupported optional-content memberships retain the annotation, its transitive
/// replies and pop-ups, and its AcroForm field links.
#[test]
fn unsupported_membership_keeps_annotations_replies_and_field_links() {
use pdfcraft_cos::Stream;
let direct_ocg = Object::Dict({
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Type".to_vec(), Object::Name(b"OCG".to_vec()));
d
});
let wrong_type = Object::Dict({
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Type".to_vec(), Object::Name(b"Other".to_vec()));
d
});
for membership in [Object::Null, Object::Int(7), Object::Ref(ObjRef::new(999, 0)), Object::Ref(ObjRef::new(7, 0)), direct_ocg, wrong_type] {
for widget in [false, true] {
let mut doc = fixture("", 4, "");
let retained = ObjRef::new(8, 0);
let mut successful = doc.get(retained).as_dict().unwrap().clone();
successful.remove(b"OC");
let successful = doc.add(Object::Dict(successful));
let empty_appearance = if widget {
let mut empty = doc.get(ObjRef::new(7, 0)).as_dict().unwrap().clone();
empty.set(b"BBox".to_vec(), Object::Array(vec![Object::Int(0); 4]));
let reference = doc.add(Object::Stream(Stream::from_raw(empty, Vec::new())));
let mut ap = pdfcraft_cos::Dict::new();
ap.set(b"N".to_vec(), Object::Ref(reference));
Some(Object::Dict(ap))
} else {
None
};
doc.update_dict(retained, |d| {
d.set(b"OC".to_vec(), membership.clone());
d.set(b"IRT".to_vec(), Object::Ref(successful));
if widget {
d.set(b"Subtype".to_vec(), Object::Name(b"Widget".to_vec()));
d.set(b"AP".to_vec(), empty_appearance.clone().unwrap());
} else {
d.remove(b"AP");
}
})
.unwrap();
let mut reply = doc.get(retained).as_dict().unwrap().clone();
reply.remove(b"OC");
reply.set(b"Subtype".to_vec(), Object::Name(b"Square".to_vec()));
reply.set(b"IRT".to_vec(), Object::Ref(retained));
reply.set(b"AP".to_vec(), doc.get(successful).as_dict().unwrap().get(b"AP").unwrap().clone());
let reply = doc.add(Object::Dict(reply));
let mut grandchild = doc.get(reply).as_dict().unwrap().clone();
grandchild.set(b"IRT".to_vec(), Object::Ref(reply));
let grandchild = doc.add(Object::Dict(grandchild));
let popup = doc.add(Object::Dict({
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Subtype".to_vec(), Object::Name(b"Popup".to_vec()));
d.set(b"Parent".to_vec(), Object::Ref(retained));
d
}));
doc.update_dict(ObjRef::new(3, 0), |d| {
d.set(
b"Annots".to_vec(),
Object::Array(vec![
Object::Ref(successful),
Object::Ref(retained),
Object::Ref(reply),
Object::Ref(grandchild),
Object::Ref(popup),
]),
)
})
.unwrap();
if widget {
let fields = doc.add(Object::Dict({
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Fields".to_vec(), Object::Array(vec![Object::Ref(retained)]));
d
}));
doc.update_dict(ObjRef::new(1, 0), |d| d.set(b"AcroForm".to_vec(), Object::Ref(fields))).unwrap();
}
let originals = [retained, reply, grandchild, popup].map(|r| (*doc.get(r)).clone());
let original_fields = doc.get(ObjRef::new(1, 0)).as_dict().unwrap().get(b"AcroForm").map(|o| (*doc.resolve(o)).clone());
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, true).unwrap(), 1, "{membership:?}");
let doc = Document::open(Arc::new(saved(&doc))).unwrap();
for (reference, original) in [retained, reply, grandchild, popup].into_iter().zip(originals) {
assert_eq!(*doc.get(reference), original);
}
let page = pdfcraft_model::pages(&doc).remove(0);
assert_eq!(
doc.resolve(page.dict.get(b"Annots").unwrap()).as_array().unwrap(),
&vec![Object::Ref(retained), Object::Ref(reply), Object::Ref(grandchild), Object::Ref(popup)]
);
assert_eq!(doc.get(ObjRef::new(1, 0)).as_dict().unwrap().get(b"AcroForm").map(|o| (*doc.resolve(o)).clone()), original_fields);
}
}
// A stream that claims Type OCG must not qualify through Object::as_dict().
let mut doc = fixture("/OC 4 0 R", 4, "");
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Type".to_vec(), Object::Name(b"OCG".to_vec()));
doc.set(ObjRef::new(4, 0), Object::Stream(Stream::from_raw(d, Vec::new())));
let before = saved(&doc);
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 0);
assert_eq!(saved(&doc), before);
// Shared-subexpression /VE fan-out (10^16 paths within depth 16) stops at the node budget
// and retains the annotation unchanged instead of hanging.
let mut doc = fixture("/OC 9 0 R", 4, "");
let mut target = ObjRef::new(4, 0);
for _ in 0..16 {
let mut expr = vec![Object::Name(b"Or".to_vec())];
expr.extend(std::iter::repeat_n(Object::Ref(target), 10));
target = doc.add(Object::Array(expr));
}
let ve = (*doc.get(target)).clone();
doc.update_dict(ObjRef::new(9, 0), |d| {
d.set(b"VE".to_vec(), ve.clone());
})
.unwrap();
let before = saved(&doc);
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 0);
assert_eq!(saved(&doc), before);
}
/// Preserve a malformed reply that targets a retained popup instead of a markup annotation.
#[test]
fn unsupported_membership_keeps_popup_replies_after_save_and_reopen() {
let mut doc = fixture("/OC null", 4, "");
let root = ObjRef::new(8, 0);
let popup = doc.add(Object::Dict({
let mut d = pdfcraft_cos::Dict::new();
d.set(b"Subtype".to_vec(), Object::Name(b"Popup".to_vec()));
d.set(b"Parent".to_vec(), Object::Ref(root));
d.set(b"Private".to_vec(), Object::String(pdfcraft_cos::PdfString::text("keep popup")));
d
}));
let mut reply = doc.get(root).as_dict().unwrap().clone();
reply.remove(b"OC");
reply.set(b"IRT".to_vec(), Object::Ref(popup));
let reply = doc.add(Object::Dict(reply));
let mut drawable = doc.get(root).as_dict().unwrap().clone();
drawable.remove(b"OC");
let drawable = doc.add(Object::Dict(drawable));
doc.update_dict(ObjRef::new(3, 0), |d| {
d.set(b"Annots".to_vec(), Object::Array([root, popup, reply, drawable].map(Object::Ref).to_vec()));
})
.unwrap();
let originals = [root, popup, reply].map(|r| (*doc.get(r)).clone());
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 1, "only the unrelated annotation can flatten");
let doc = Document::open(Arc::new(saved(&doc))).unwrap();
for (reference, original) in [root, popup, reply].into_iter().zip(originals) {
assert_eq!(*doc.get(reference), original, "the retained popup graph stays unchanged");
}
let page = pdfcraft_model::pages(&doc).remove(0);
assert_eq!(doc.resolve(page.dict.get(b"Annots").unwrap()).as_array().unwrap(), &[root, popup, reply].map(Object::Ref));
assert_eq!(paint_memberships(&doc), vec![(ObjRef::new(7, 0), None)]);
}
/// Undrawable text in a retained reply must not block an unrelated drawable annotation.
#[test]
fn unsupported_membership_keeps_undrawable_reply_without_refusing_flatten() {
for marked_appearance in [false, true] {
let mut doc = fixture("/OC null", 4, "");
let root = ObjRef::new(8, 0);
let mut reply = doc.get(root).as_dict().unwrap().clone();
reply.remove(b"OC");
reply.set(b"Subtype".to_vec(), Object::Name(b"FreeText".to_vec()));
reply.set(b"IRT".to_vec(), Object::Ref(root));
reply.set(b"Contents".to_vec(), Object::String(pdfcraft_cos::PdfString::text("漢")));
if marked_appearance {
pdfcraft_fonts::set_undrawn_mark(&mut reply, Some('漢'));
} else {
reply.remove(b"AP");
}
assert_eq!(pdfcraft_annot::appearance::undrawable_text(&reply).map(|(_, c)| c), Some('漢'));
let reply = doc.add(Object::Dict(reply));
let mut drawable = doc.get(root).as_dict().unwrap().clone();
drawable.remove(b"OC");
let drawable = doc.add(Object::Dict(drawable));
doc.update_dict(ObjRef::new(3, 0), |d| {
d.set(b"Annots".to_vec(), Object::Array([root, reply, drawable].map(Object::Ref).to_vec()));
})
.unwrap();
// Compare serialized dictionaries before and after flatten, including PDF string syntax.
let mut doc = Document::open(Arc::new(saved(&doc))).unwrap();
let originals = [root, reply].map(|r| (*doc.get(r)).clone());
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 1, "retained text is not baked into page content");
let doc = Document::open(Arc::new(saved(&doc))).unwrap();
for (reference, original) in [root, reply].into_iter().zip(originals) {
assert_eq!(*doc.get(reference), original);
}
let page = pdfcraft_model::pages(&doc).remove(0);
assert_eq!(doc.resolve(page.dict.get(b"Annots").unwrap()).as_array().unwrap(), &[root, reply].map(Object::Ref));
assert_eq!(paint_memberships(&doc), vec![(ObjRef::new(7, 0), None)]);
}
}
/// Verify that shared/inherited `/Resources` and `/Properties` dictionaries are never mutated in
/// place and that consecutive flatten runs allocate distinct `/PCFlOC{n}` property names.
#[test]
fn flatten_preserves_shared_resources_and_uses_new_names_on_each_call() {
for inherited in [false, true] {
for indirect in [false, true] {
let mut doc = fixture("/OC 4 0 R", 4, "");
let mut resources = doc.get(ObjRef::new(3, 0)).as_dict().unwrap().get(b"Resources").unwrap().as_dict().unwrap().clone();
let original_properties = resources.get(b"Properties").unwrap().clone();
if indirect {
let r = doc.add(original_properties.clone());
resources.set(b"Properties".to_vec(), Object::Ref(r));
}
let resources = if indirect { Object::Ref(doc.add(Object::Dict(resources))) } else { Object::Dict(resources) };
let owner = ObjRef::new(if inherited { 2 } else { 3 }, 0);
if inherited {
doc.update_dict(ObjRef::new(3, 0), |d| {
d.remove(b"Resources");
})
.unwrap();
}
doc.update_dict(owner, |d| d.set(b"Resources".to_vec(), resources.clone())).unwrap();
let original_resource_object = (*doc.resolve(&resources)).clone();
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 1);
doc.update_dict(ObjRef::new(3, 0), |d| d.set(b"Annots".to_vec(), Object::Array(vec![Object::Ref(ObjRef::new(8, 0))]))).unwrap();
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 1);
let doc = Document::open(Arc::new(saved(&doc))).unwrap();
assert_eq!(paint_memberships(&doc), vec![(ObjRef::new(7, 0), Some(Object::Ref(ObjRef::new(4, 0)))); 2]);
let page = pdfcraft_model::pages(&doc).remove(0);
let effective = doc.resolve(page.dict.get(b"Resources").unwrap());
let properties = doc.resolve(effective.as_dict().unwrap().get(b"Properties").unwrap());
let properties = properties.as_dict().unwrap();
for (key, value) in original_properties.as_dict().unwrap().iter() {
assert_eq!(properties.get(key), Some(value));
}
assert_eq!(properties.len(), original_properties.as_dict().unwrap().len() + 2);
if inherited || indirect {
assert_eq!(*doc.resolve(&resources), original_resource_object);
}
}
}
}
/// Verify that malformed `/Resources` or `/Properties` entries retain `/OC` annotations without
/// generating appearances, while inline annotations with valid `/OC` still flatten cleanly.
#[test]
fn malformed_resources_and_direct_ocg_stay_unchanged_before_appearance_generation() {
for malformed_resources in [false, true] {
let mut doc = fixture("/OC 4 0 R", 4, "");
if malformed_resources {
doc.update_dict(ObjRef::new(3, 0), |d| d.set(b"Resources".to_vec(), Object::Null)).unwrap();
} else {
let mut resources = doc.get(ObjRef::new(3, 0)).as_dict().unwrap().get(b"Resources").unwrap().as_dict().unwrap().clone();
resources.set(b"Properties".to_vec(), Object::Int(1));
doc.update_dict(ObjRef::new(3, 0), |d| d.set(b"Resources".to_vec(), Object::Dict(resources))).unwrap();
}
doc.update_dict(ObjRef::new(8, 0), |d| {
d.remove(b"AP");
})
.unwrap();
let before = saved(&doc);
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 0);
assert_eq!(saved(&doc), before);
}
let mut doc = fixture("/OC 4 0 R", 4, "");
let annotation = doc.get(ObjRef::new(8, 0)).as_dict().unwrap().clone();
doc.update_dict(ObjRef::new(3, 0), |d| d.set(b"Annots".to_vec(), Object::Array(vec![Object::Dict(annotation)]))).unwrap();
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 1);
let doc = Document::open(Arc::new(saved(&doc))).unwrap();
assert_eq!(paint_memberships(&doc), vec![(ObjRef::new(7, 0), Some(Object::Ref(ObjRef::new(4, 0))))]);
}
/// Inline replies and inline popups pointing to a retained annotation are kept in /Annots.
#[test]
fn unsupported_membership_keeps_inline_replies_and_popups_after_save_and_reopen() {
let mut doc = fixture("/OC null", 4, "");
let root = ObjRef::new(8, 0);
let mut inline_reply = doc.get(root).as_dict().unwrap().clone();
inline_reply.remove(b"OC");
inline_reply.set(b"IRT".to_vec(), Object::Ref(root));
let mut indirect_reply = doc.get(root).as_dict().unwrap().clone();
indirect_reply.remove(b"OC");
indirect_reply.set(b"IRT".to_vec(), Object::Ref(root));
let indirect_reply = doc.add(Object::Dict(indirect_reply));
let mut inline_grandchild = doc.get(root).as_dict().unwrap().clone();
inline_grandchild.remove(b"OC");
inline_grandchild.set(b"IRT".to_vec(), Object::Ref(indirect_reply));
let mut inline_popup = pdfcraft_cos::Dict::new();
inline_popup.set(b"Subtype".to_vec(), Object::Name(b"Popup".to_vec()));
inline_popup.set(b"Parent".to_vec(), Object::Ref(root));
let mut drawable = doc.get(root).as_dict().unwrap().clone();
drawable.remove(b"OC");
let drawable = doc.add(Object::Dict(drawable));
doc.update_dict(ObjRef::new(3, 0), |d| {
d.set(
b"Annots".to_vec(),
Object::Array(vec![
Object::Dict(inline_reply.clone()),
Object::Ref(root),
Object::Ref(indirect_reply),
Object::Dict(inline_grandchild.clone()),
Object::Dict(inline_popup.clone()),
Object::Ref(drawable),
]),
)
})
.unwrap();
assert_eq!(pdfcraft_edit::flatten(&mut doc, &[0], true, false).unwrap(), 1);
let doc = Document::open(Arc::new(saved(&doc))).unwrap();
let page = pdfcraft_model::pages(&doc).remove(0);
let annots = doc.resolve(page.dict.get(b"Annots").unwrap()).as_array().unwrap().clone();
assert_eq!(annots.len(), 5);
assert_eq!(annots[0], Object::Dict(inline_reply));
assert_eq!(annots[1], Object::Ref(root));
assert_eq!(annots[2], Object::Ref(indirect_reply));
assert_eq!(annots[3], Object::Dict(inline_grandchild));
assert_eq!(annots[4], Object::Dict(inline_popup));
}
Reference in New Issue View Git Blame Copy Permalink