use crate::nntree::NameTree;
use crate::{Error, ObjectHandle, ObjectRef, Pdf, Result};
use std::collections::BTreeMap;
use std::io::{Read, Seek};
pub struct EmbeddedFileDocumentHelper<'a, R: Read + Seek + 'static> {
pdf: &'a mut Pdf<R>,
}
fn embedded_files_tree_with_options<R: Read + Seek>(
pdf: &mut Pdf<R>,
auto_repair: bool,
max_depth: Option<usize>,
) -> Result<Option<NameTree>> {
let catalog = pdf.root_handle()?;
let names_seed = catalog.try_get_key(b"/Names")?;
names_seed.try_dereference()?;
let names = names_seed;
if !names.try_is_dictionary()? {
return Ok(None);
}
let root_seed = names.try_get_key(b"/EmbeddedFiles")?;
root_seed.try_dereference()?;
let root = root_seed;
if !root.try_is_dictionary()? {
return Ok(None);
}
let mut tree = NameTree::new(root, auto_repair);
if let Some(max_depth) = max_depth {
tree.set_max_depth(max_depth);
}
Ok(Some(tree))
}
impl<'a, R: Read + Seek> EmbeddedFileDocumentHelper<'a, R> {
pub fn new(pdf: &'a mut Pdf<R>) -> Self {
Self { pdf }
}
fn embedded_files_tree(&mut self) -> Result<Option<NameTree>> {
embedded_files_tree_with_options(self.pdf, true, None)
}
fn ensure_embedded_files_tree(&mut self) -> Result<Option<NameTree>> {
if let Some(tree) = self.embedded_files_tree()? {
return Ok(Some(tree));
}
let catalog = self.pdf.root_handle()?;
let names = if catalog.try_has_key(b"/Names")? {
let candidate = catalog.try_get_key(b"/Names")?;
candidate.try_dereference()?;
let names = candidate;
if names.try_is_dictionary()? {
names
} else {
let names = ObjectHandle::dictionary(Vec::new());
catalog.replace_key(b"/Names", names.clone())?;
names
}
} else {
let names = ObjectHandle::dictionary(Vec::new());
catalog.replace_key(b"/Names", names.clone())?;
names
};
let root = self.new_empty_embedded_files_root(&names)?;
Ok(Some(NameTree::new(root, true)))
}
fn new_empty_embedded_files_root(&mut self, names: &ObjectHandle) -> Result<ObjectHandle> {
let root = self
.pdf
.make_indirect_from_object_handle(ObjectHandle::dictionary(vec![(
b"/Names".to_vec(),
ObjectHandle::array(Vec::new()),
)]))?;
names.replace_key(b"/EmbeddedFiles", root.clone())?;
Ok(root)
}
pub fn has_embedded_files(&mut self) -> Result<bool> {
Ok(self.embedded_files_tree()?.is_some())
}
pub fn get_embedded_files(&mut self) -> Result<BTreeMap<Vec<u8>, ObjectHandle>> {
let Some(mut tree) = self.embedded_files_tree()? else {
return Ok(BTreeMap::new());
};
tree.as_map(self.pdf)
}
pub fn get_embedded_file(&mut self, key: &[u8]) -> Result<Option<ObjectHandle>> {
let Some(mut tree) = self.embedded_files_tree()? else {
return Ok(None);
};
tree.find_object(self.pdf, key)
}
pub fn replace_embedded_file(&mut self, key: &[u8], filespec: ObjectHandle) -> Result<()> {
if let Some(object_ref) = filespec.object_ref() {
if !self.pdf.is_canonical_object_handle(&filespec) {
return Err(Error::Unsupported(
"filespec handle belongs to another Pdf".to_string(),
));
}
debug_assert_eq!(filespec.object_ref(), Some(object_ref));
} else if !filespec.belongs_to_pdf(self.pdf.unique_id()) {
return Err(Error::Unsupported(
"filespec handle belongs to another Pdf".to_string(),
));
}
let Some(mut tree) = self.ensure_embedded_files_tree()? else {
return Ok(());
};
tree.insert(self.pdf, key, filespec).map(|_| ())
}
pub fn remove_embedded_file(&mut self, key: &[u8]) -> Result<bool> {
let Some(mut tree) = self.embedded_files_tree()? else {
return Ok(false);
};
let Some(removed) = tree.remove(self.pdf, key)? else {
return Ok(false);
};
if let Some(object_ref) = removed.object_ref() {
self.pdf.replace_object(object_ref, ObjectHandle::null())?;
}
Ok(true)
}
}
impl<R: Read + Seek> Pdf<R> {
pub fn embedded_files(&mut self) -> EmbeddedFileDocumentHelper<'_, R> {
EmbeddedFileDocumentHelper::new(self)
}
}
pub fn remove_attachment<R: Read + Seek>(pdf: &mut Pdf<R>, key: &[u8]) -> Result<bool> {
let removed = pdf.embedded_files().remove_embedded_file(key)?;
if !removed {
return Ok(false);
}
Ok(true)
}
#[cfg(test)]
fn embedded_file_stream_ref<R: Read + Seek + 'static>(
pdf: &mut Pdf<R>,
filespec_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let candidate = {
let filespec = pdf.get_object_handle(filespec_ref);
let mut filespec = crate::filespec_helper::FileSpec::new(filespec, pdf)?;
filespec.get_embedded_file_stream("")?
};
Ok(candidate.object_ref())
}
pub const DEFAULT_MAX_EMBEDDED_FILES_DEPTH: usize = 100;
pub fn list_embedded_files<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<Vec<(Vec<u8>, ObjectRef)>> {
list_embedded_files_with_max_depth(pdf, DEFAULT_MAX_EMBEDDED_FILES_DEPTH)
}
pub fn list_embedded_files_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Vec<(Vec<u8>, ObjectRef)>> {
let Some(mut tree) = embedded_files_tree_with_options(pdf, true, Some(max_depth))? else {
return Ok(vec![]);
};
Ok(tree
.as_map(pdf)?
.into_iter()
.filter_map(|(key, value)| {
value
.object_ref()
.or_else(|| value.object_ref())
.map(|object_ref| (key, object_ref))
})
.collect())
}
pub fn insert_embedded_file<R: Read + Seek>(
pdf: &mut Pdf<R>,
key: &[u8],
filespec_ref: ObjectRef,
) -> Result<()> {
let filespec = pdf.get_object_handle(filespec_ref);
pdf.embedded_files().replace_embedded_file(key, filespec)
}
pub fn delete_embedded_file<R: Read + Seek>(pdf: &mut Pdf<R>, key: &[u8]) -> Result<bool> {
pdf.embedded_files().remove_embedded_file(key)
}
#[cfg(test)]
#[allow(deprecated)]
mod tests {
use super::*;
use crate::filespec_helper::FileSpecBuilder;
use crate::job::add_attachment_from_path;
fn minimal_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open_minimal() -> Pdf<std::io::Cursor<Vec<u8>>> {
Pdf::open(std::io::Cursor::new(minimal_pdf_bytes())).expect("open minimal PDF")
}
fn next_object_number(pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>) -> u32 {
pdf.next_available_object_ref()
.expect("object-number space must have room in the test fixture")
.number
.checked_sub(1)
.expect("minimal test fixture has object 1 as its first object")
}
fn handle_array(items: Vec<ObjectHandle>) -> ObjectHandle {
ObjectHandle::array(items)
}
fn handle_dictionary(entries: Vec<(&[u8], ObjectHandle)>) -> ObjectHandle {
ObjectHandle::dictionary(
entries
.into_iter()
.map(|(key, value)| (key.to_vec(), value))
.collect(),
)
}
fn set_test_object(
pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>,
object_ref: ObjectRef,
value: ObjectHandle,
) -> ObjectHandle {
pdf.replace_object(object_ref, value)
.expect("set canonical test object");
pdf.get_object_handle(object_ref)
}
fn resolved_handle(
pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>,
object_ref: ObjectRef,
) -> ObjectHandle {
let handle = pdf.get_object_handle(object_ref);
handle
.try_is_scalar()
.expect("resolve canonical test object");
handle
}
fn catalog_handle(pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>) -> ObjectHandle {
let catalog_ref = pdf.root_ref().expect("root");
resolved_handle(pdf, catalog_ref)
}
fn rewritten(pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>) -> Pdf<std::io::Cursor<Vec<u8>>> {
let bytes = crate::writer::write_qpdf_to_memory(pdf, |_| {}).expect("rewrite PDF");
Pdf::open(std::io::Cursor::new(bytes)).expect("reopen rewritten PDF")
}
fn count_streams(pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>) -> usize {
let objects = pdf.get_all_objects().expect("enumerate rewritten objects");
objects
.into_iter()
.filter(|object| {
object.try_is_scalar().expect("resolve rewritten object");
object.as_stream_dict().is_some()
})
.count()
}
fn count_embedded_file_streams(pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>) -> usize {
let objects = pdf.get_all_objects().expect("enumerate rewritten objects");
objects
.into_iter()
.filter(|object| {
object.try_is_scalar().expect("resolve rewritten object");
let Some(dict) = object.as_stream_dict() else {
return false;
};
let kind = dict.try_get_key(b"/Type").unwrap();
kind.try_is_scalar().expect("resolve embedded stream type");
kind.as_name().as_deref() == Some(b"EmbeddedFile")
})
.count()
}
fn replace_catalog_key(
pdf: &mut Pdf<std::io::Cursor<Vec<u8>>>,
key: &[u8],
value: ObjectHandle,
) {
let catalog = catalog_handle(pdf);
catalog
.replace_key(key, value)
.expect("replace catalog key");
}
fn indirect_names_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Names 4 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /EmbeddedFiles << /Names [ (entry) 5 0 R ] >> >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Type /Filespec /F (entry.txt) >>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3, off4, off5,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn remove_one_of_two_leaves_other_intact() {
let mut pdf = open_minimal();
let dir = tempfile::tempdir().expect("tempdir");
let file_a = dir.path().join("a.txt");
let file_b = dir.path().join("b.txt");
std::fs::write(&file_a, b"content A").unwrap();
std::fs::write(&file_b, b"content B").unwrap();
add_attachment_from_path(&mut pdf, b"a.txt", &file_a).expect("add a");
let fs_b = add_attachment_from_path(&mut pdf, b"b.txt", &file_b).expect("add b");
let removed = remove_attachment(&mut pdf, b"a.txt").expect("remove a");
assert!(
removed,
"remove_attachment must return true for existing key"
);
let entries = list_embedded_files(&mut pdf).expect("list");
assert_eq!(entries.len(), 1, "exactly one attachment must remain");
assert_eq!(entries[0].0, b"b.txt", "b.txt must survive");
assert_eq!(entries[0].1, fs_b, "surviving filespec ref must match");
let keys: Vec<&[u8]> = entries.iter().map(|(k, _)| k.as_slice()).collect();
assert!(!keys.contains(&b"a.txt".as_ref()), "a.txt must be gone");
}
#[test]
fn helper_reads_preserve_an_unchanged_indirect_names_dictionary() {
let mut pdf = Pdf::open(std::io::Cursor::new(indirect_names_pdf_bytes())).expect("open");
assert_eq!(
pdf.embedded_files()
.get_embedded_files()
.expect("list")
.len(),
1
);
assert!(pdf
.embedded_files()
.get_embedded_file(b"entry")
.expect("lookup")
.is_some());
}
#[test]
fn helper_absent_removal_preserves_an_unchanged_indirect_names_dictionary() {
let mut pdf = Pdf::open(std::io::Cursor::new(indirect_names_pdf_bytes())).expect("open");
assert!(!pdf
.embedded_files()
.remove_embedded_file(b"missing")
.expect("absent removal"));
}
#[test]
fn legacy_insert_updates_retained_embedded_files_root() {
let mut pdf = Pdf::open(std::io::Cursor::new(indirect_names_pdf_bytes())).expect("open");
let catalog_ref = pdf.root_ref().expect("root");
let catalog = pdf.get_object_handle(catalog_ref);
catalog.try_is_scalar().expect("resolve catalog");
let retained_root = catalog
.try_get_key(b"/Names")
.unwrap()
.try_get_key(b"/EmbeddedFiles")
.unwrap();
retained_root
.try_is_scalar()
.expect("resolve embedded-files root");
let filespec_ref = ObjectRef::new(90, 0);
set_test_object(&mut pdf, filespec_ref, handle_dictionary(Vec::new()));
insert_embedded_file(&mut pdf, b"new.txt", filespec_ref).expect("insert");
let pairs = retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("retained names array");
assert_eq!(pairs.len(), 4, "the retained root must observe insertion");
assert_eq!(pairs[2].as_string(), Some(b"new.txt".to_vec()));
}
#[test]
fn remove_attachment_preserves_retained_af_array_handle_and_nulls_filespec() {
let mut pdf = open_minimal();
let filespec_ref = FileSpecBuilder::new("retained-af.txt", b"payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"retained-af.txt", filespec_ref).expect("insert");
let af_ref = ObjectRef::new(next_object_number(&mut pdf) + 1, 0);
let filespec_handle = pdf.get_object_handle(filespec_ref);
set_test_object(&mut pdf, af_ref, handle_array(vec![filespec_handle]));
let af_handle = pdf.get_object_handle(af_ref);
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/AF", af_handle.clone())
.expect("replace catalog /AF");
let page_ref = crate::pages::page_refs(&mut pdf)
.expect("page refs")
.into_iter()
.next()
.expect("page");
let page = resolved_handle(&mut pdf, page_ref);
page.replace_key(b"/AF", af_handle)
.expect("replace page /AF");
let retained_af = pdf.get_object_handle(af_ref);
retained_af.try_is_scalar().expect("resolve AF array");
assert!(
remove_attachment(&mut pdf, b"retained-af.txt").expect("remove"),
"attachment must be found"
);
assert_eq!(
retained_af.as_array().expect("retained AF array").len(),
1,
"qpdf keeps the retained AF array element"
);
assert!(
resolved_handle(&mut pdf, filespec_ref).is_null(),
"qpdf replaces the removed Filespec with null"
);
}
#[test]
fn helper_mutates_a_retained_direct_embedded_files_root() {
let mut pdf = open_minimal();
let root = handle_dictionary(vec![(b"/Names", handle_array(Vec::new()))]);
let names = handle_dictionary(vec![(b"/EmbeddedFiles", root)]);
replace_catalog_key(&mut pdf, b"/Names", names);
let catalog_handle = catalog_handle(&mut pdf);
let retained_root = catalog_handle
.try_get_key(b"/Names")
.unwrap()
.try_get_key(b"/EmbeddedFiles")
.unwrap();
let retained_pairs = retained_root.try_get_key(b"/Names").unwrap();
let filespec_ref = ObjectRef::new(90, 0);
set_test_object(&mut pdf, filespec_ref, handle_dictionary(Vec::new()));
let filespec = pdf.get_object_handle(filespec_ref);
pdf.embedded_files()
.replace_embedded_file(b"entry", filespec)
.expect("replace");
assert!(
retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.is_some_and(|pairs| pairs.len() == 2),
"a retained direct root must observe helper replacement"
);
assert_eq!(
retained_pairs
.as_array()
.expect("retained names array")
.len(),
2,
"a retained direct leaf array must observe helper replacement"
);
assert!(pdf
.embedded_files()
.remove_embedded_file(b"entry")
.expect("remove"));
assert_eq!(
retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("names array")
.len(),
0,
"a retained direct root must observe helper removal"
);
assert_eq!(
retained_pairs
.as_array()
.expect("retained names array")
.len(),
0,
"a retained direct leaf array must observe helper removal"
);
assert!(pdf.embedded_files().has_embedded_files().expect("has tree"));
assert!(!pdf
.embedded_files()
.remove_embedded_file(b"missing")
.expect("missing removal"));
}
#[test]
fn helper_mutates_an_indirect_root_without_detaching_direct_filespec_handle() {
let mut pdf = open_minimal();
let root_ref = ObjectRef::new(90, 0);
let added_ref = ObjectRef::new(91, 0);
let existing_filespec =
handle_dictionary(vec![(b"/F", ObjectHandle::string(b"old.txt".to_vec()))]);
let root = handle_dictionary(vec![(
b"/Names",
handle_array(vec![ObjectHandle::string(b"a".to_vec()), existing_filespec]),
)]);
let root_handle = set_test_object(&mut pdf, root_ref, root);
set_test_object(&mut pdf, added_ref, handle_dictionary(Vec::new()));
let names = handle_dictionary(vec![(b"/EmbeddedFiles", root_handle)]);
replace_catalog_key(&mut pdf, b"/Names", names);
let catalog_handle = catalog_handle(&mut pdf);
let retained_root = catalog_handle
.try_get_key(b"/Names")
.unwrap()
.try_get_key(b"/EmbeddedFiles")
.unwrap();
retained_root
.try_is_scalar()
.expect("resolve embedded-files root");
let retained_filespec = retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("names array")[1]
.clone();
let added = pdf.get_object_handle(added_ref);
pdf.embedded_files()
.replace_embedded_file(b"b", added)
.expect("replace");
pdf.embedded_files()
.replace_embedded_file(b"c", retained_filespec.clone())
.expect("insert direct filespec");
let inserted_direct = pdf
.embedded_files()
.get_embedded_file(b"c")
.expect("lookup direct filespec")
.expect("direct filespec");
assert!(
inserted_direct.is_same_object_as(&retained_filespec),
"qpdf stores the direct Filespec handle itself in the name tree"
);
assert!(pdf
.embedded_files()
.remove_embedded_file(b"b")
.expect("remove indirect filespec"));
retained_filespec
.replace_key(b"/F", ObjectHandle::string(b"new.txt".to_vec()))
.unwrap();
let current_filespec = retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("updated names array")[1]
.clone();
assert_eq!(
current_filespec.try_get_key(b"/F").unwrap().as_string(),
Some(b"new.txt".to_vec())
);
}
#[test]
fn helper_mutates_a_retained_direct_kids_root() {
let mut pdf = open_minimal();
let leaf = handle_dictionary(vec![
(
b"/Names",
handle_array(vec![
ObjectHandle::string(b"a".to_vec()),
ObjectHandle::integer(1),
]),
),
(
b"/Limits",
handle_array(vec![
ObjectHandle::string(b"a".to_vec()),
ObjectHandle::string(b"a".to_vec()),
]),
),
]);
let root = handle_dictionary(vec![(b"/Kids", handle_array(vec![leaf]))]);
let names = handle_dictionary(vec![(b"/EmbeddedFiles", root)]);
replace_catalog_key(&mut pdf, b"/Names", names);
let catalog_handle = catalog_handle(&mut pdf);
let retained_root = catalog_handle
.try_get_key(b"/Names")
.unwrap()
.try_get_key(b"/EmbeddedFiles")
.unwrap();
let filespec_ref = ObjectRef::new(90, 0);
set_test_object(&mut pdf, filespec_ref, handle_dictionary(Vec::new()));
let filespec = pdf.get_object_handle(filespec_ref);
pdf.embedded_files()
.replace_embedded_file(b"b", filespec)
.expect("replace");
assert!(
retained_root
.try_get_key(b"/Kids")
.unwrap()
.as_array()
.and_then(|kids| kids.first().cloned())
.is_some_and(|kid| kid.is_indirect()),
"a retained direct /Kids root must observe direct-kid repair"
);
}
#[test]
fn helper_preserves_an_untouched_direct_filespec_handle_during_root_update() {
let mut pdf = open_minimal();
let filespec = handle_dictionary(vec![
(b"/Type", ObjectHandle::name(b"Filespec".to_vec())),
(b"/F", ObjectHandle::string(b"old.txt".to_vec())),
]);
let root = handle_dictionary(vec![(
b"/Names",
handle_array(vec![ObjectHandle::string(b"a".to_vec()), filespec]),
)]);
let names = handle_dictionary(vec![(b"/EmbeddedFiles", root)]);
replace_catalog_key(&mut pdf, b"/Names", names);
let catalog_handle = catalog_handle(&mut pdf);
let retained_root = catalog_handle
.try_get_key(b"/Names")
.unwrap()
.try_get_key(b"/EmbeddedFiles")
.unwrap();
let retained_filespec = retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("names array")[1]
.clone();
let added_ref = ObjectRef::new(90, 0);
set_test_object(&mut pdf, added_ref, handle_dictionary(Vec::new()));
let added = pdf.get_object_handle(added_ref);
pdf.embedded_files()
.replace_embedded_file(b"b", added)
.expect("replace");
retained_filespec
.replace_key(b"/F", ObjectHandle::string(b"new.txt".to_vec()))
.unwrap();
let current_filespec = retained_root
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("updated names array")[1]
.clone();
assert_eq!(
current_filespec.try_get_key(b"/F").unwrap().as_string(),
Some(b"new.txt".to_vec())
);
}
#[test]
fn remove_attachment_sweeps_transitively_unreachable_subgraph() {
let mut pdf = open_minimal();
let next = next_object_number(&mut pdf);
let sidecar_ref = ObjectRef::new(next + 1, 0);
let sidecar = ObjectHandle::stream(
ObjectHandle::dictionary(Vec::new()),
std::rc::Rc::new(b"sidecar".to_vec()),
);
set_test_object(&mut pdf, sidecar_ref, sidecar);
let fs_ref = FileSpecBuilder::new("trans.txt", b"payload")
.build(&mut pdf)
.expect("build filespec");
let filespec = resolved_handle(&mut pdf, fs_ref);
filespec
.replace_key(b"/CI", pdf.get_object_handle(sidecar_ref))
.expect("add side-car reference");
insert_embedded_file(&mut pdf, b"trans.txt", fs_ref).expect("insert");
remove_attachment(&mut pdf, b"trans.txt").expect("remove");
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&fs_ref),
"filespec remains in memory until the writer runs"
);
assert!(
live.contains(&sidecar_ref),
"side-car remains in memory until the writer runs"
);
let mut written = rewritten(&mut pdf);
assert_eq!(
count_streams(&mut written),
0,
"writer must drop the stream reachable only through the removed filespec"
);
}
#[test]
fn embedded_file_stream_ref_accepts_indirect_ef_dict() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("indirect-ef.txt", b"payload")
.build(&mut pdf)
.expect("build filespec");
let filespec = resolved_handle(&mut pdf, fs_ref);
let ef_dict = filespec
.try_get_key(b"/EF")
.unwrap()
.as_dictionary()
.expect("/EF dict");
let ef_ref = ObjectRef::new(fs_ref.number + 100, 0);
let ef_handle = ObjectHandle::dictionary(ef_dict.into_iter().collect());
set_test_object(&mut pdf, ef_ref, ef_handle);
filespec
.replace_key(b"/EF", pdf.get_object_handle(ef_ref))
.expect("replace /EF with indirect dictionary");
let stream_ref = embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream")
.expect("stream ref");
assert!(pdf.canonical_object_refs().contains(&stream_ref));
}
#[test]
fn remove_attachment_gc_deletes_filespec_and_stream() {
let mut pdf = open_minimal();
let dir = tempfile::tempdir().expect("tempdir");
let file = dir.path().join("gc.txt");
std::fs::write(&file, b"gc test").unwrap();
let fs_ref = add_attachment_from_path(&mut pdf, b"gc.txt", &file).expect("add");
let stream_ref = embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve_stream_ref")
.expect("stream ref must exist");
remove_attachment(&mut pdf, b"gc.txt").expect("remove");
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&fs_ref),
"filespec remains in memory before writer output"
);
assert!(
live.contains(&stream_ref),
"stream remains in memory before writer output"
);
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 0);
assert!(list_embedded_files(&mut written)
.expect("list rewritten attachments")
.is_empty());
}
#[test]
fn remove_attachment_with_indirect_af_array_gcs_filespec_and_stream() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("idx.txt", b"indirect-af payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"idx.txt", fs_ref).expect("insert");
let stream_ref = embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream ref")
.expect("stream ref must exist");
let next = next_object_number(&mut pdf);
let af_array_ref = ObjectRef::new(next + 1, 0);
let filespec_handle = pdf.get_object_handle(fs_ref);
set_test_object(&mut pdf, af_array_ref, handle_array(vec![filespec_handle]));
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/AF", pdf.get_object_handle(af_array_ref))
.expect("replace catalog /AF");
let removed = remove_attachment(&mut pdf, b"idx.txt").expect("remove");
assert!(removed);
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&fs_ref),
"null Filespec must remain reachable through the indirect /AF array"
);
assert!(
live.contains(&stream_ref),
"embedded stream remains in memory before writer output"
);
assert!(
live.contains(&af_array_ref),
"qpdf keeps the indirect /AF array referenced by the catalog"
);
let catalog2 = catalog_handle(&mut pdf);
assert_eq!(
catalog2.try_get_key(b"/AF").unwrap().object_ref(),
Some(af_array_ref),
"catalog /AF must remain in place"
);
assert!(
resolved_handle(&mut pdf, fs_ref).is_null(),
"Filespec must be nulled, not removed"
);
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 0);
}
#[test]
fn remove_attachment_shared_indirect_af_across_catalog_and_page_not_dangled() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("sh.txt", b"shared-af payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"sh.txt", fs_ref).expect("insert");
let next = next_object_number(&mut pdf);
let af_array_ref = ObjectRef::new(next + 1, 0);
let filespec_handle = pdf.get_object_handle(fs_ref);
set_test_object(&mut pdf, af_array_ref, handle_array(vec![filespec_handle]));
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/AF", pdf.get_object_handle(af_array_ref))
.expect("replace catalog /AF");
let page_refs = crate::pages::page_refs(&mut pdf).expect("page_refs");
assert_eq!(page_refs.len(), 1, "fixture has one page");
let page_ref = page_refs[0];
let page = resolved_handle(&mut pdf, page_ref);
page.replace_key(b"/AF", pdf.get_object_handle(af_array_ref))
.expect("replace page /AF");
let removed = remove_attachment(&mut pdf, b"sh.txt").expect("remove");
assert!(removed);
let af_after = resolved_handle(&mut pdf, af_array_ref)
.as_array()
.expect("shared indirect /AF array must still resolve (not deleted)");
assert_eq!(
af_after.len(),
1,
"shared /AF array must retain the nulled Filespec reference"
);
assert_eq!(af_after[0].object_ref(), Some(fs_ref));
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&fs_ref),
"null Filespec must remain reachable through the shared /AF array"
);
let page_after = resolved_handle(&mut pdf, page_ref);
assert_eq!(
page_after.try_get_key(b"/AF").unwrap().object_ref(),
Some(af_array_ref),
"page /AF must still point at the surviving shared array"
);
assert!(
resolved_handle(&mut pdf, fs_ref).is_null(),
"Filespec must be nulled, not removed"
);
}
#[test]
fn remove_attachment_preserves_filespec_referenced_by_other_name_tree() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("shared.txt", b"shared payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"shared.txt", fs_ref).expect("insert");
let stream_ref = embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream ref")
.expect("stream ref must exist");
let next = next_object_number(&mut pdf);
let dests_leaf_ref = ObjectRef::new(next + 1, 0);
let dests_leaf = handle_dictionary(vec![(
b"/Names",
handle_array(vec![
ObjectHandle::string(b"shared-dest".to_vec()),
pdf.get_object_handle(fs_ref),
]),
)]);
set_test_object(&mut pdf, dests_leaf_ref, dests_leaf);
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/Dests", pdf.get_object_handle(dests_leaf_ref))
.expect("replace catalog /Dests");
let removed = remove_attachment(&mut pdf, b"shared.txt").expect("remove");
assert!(removed, "existing key must report removed");
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&fs_ref),
"the null Filespec ref remains reachable through /Dests"
);
assert!(
resolved_handle(&mut pdf, fs_ref).is_null(),
"qpdf replaces the shared Filespec with null"
);
let leaf = resolved_handle(&mut pdf, dests_leaf_ref);
let names = leaf
.try_get_key(b"/Names")
.unwrap()
.as_array()
.expect("dests leaf names");
assert!(
names.iter().any(|value| value.object_ref() == Some(fs_ref)),
"/Dests leaf must still reference the filespec"
);
assert!(
live.contains(&stream_ref),
"embedded stream remains in memory before writer output"
);
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 0);
}
#[test]
fn remove_attachment_keeps_external_stream_but_collects_nulled_filespec() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("paired.txt", b"paired payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"paired.txt", fs_ref).expect("insert");
let stream_ref = embedded_file_stream_ref(&mut pdf, fs_ref)
.expect("resolve stream ref")
.expect("stream ref must exist");
let stream = resolved_handle(&mut pdf, stream_ref);
let stream_dict = stream.as_stream_dict().expect("stream dictionary");
stream_dict
.replace_key(b"/RelatedFS", pdf.get_object_handle(fs_ref))
.expect("add stream back-reference");
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/ExtraStreamRef", pdf.get_object_handle(stream_ref))
.expect("replace catalog stream reference");
let removed = remove_attachment(&mut pdf, b"paired.txt").expect("remove");
assert!(removed);
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&stream_ref),
"externally-referenced stream remains in memory"
);
assert!(live.contains(&fs_ref), "nulled filespec remains in memory");
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 1);
assert!(list_embedded_files(&mut written)
.expect("list rewritten attachments")
.is_empty());
}
#[test]
fn remove_attachment_with_shared_stream_keeps_stream_and_other_filespec() {
let mut pdf = open_minimal();
let fs_a = FileSpecBuilder::new("a.txt", b"shared body")
.build(&mut pdf)
.expect("build a");
insert_embedded_file(&mut pdf, b"a.txt", fs_a).expect("insert a");
let shared_stream = embedded_file_stream_ref(&mut pdf, fs_a)
.expect("resolve stream a")
.expect("stream a exists");
let next = next_object_number(&mut pdf);
let fs_b = ObjectRef::new(next + 1, 0);
let ef = handle_dictionary(vec![
(b"/F", pdf.get_object_handle(shared_stream)),
(b"/UF", pdf.get_object_handle(shared_stream)),
]);
let fs_b_handle = handle_dictionary(vec![
(b"/Type", ObjectHandle::name(b"Filespec".to_vec())),
(b"/F", ObjectHandle::string(b"b.txt".to_vec())),
(b"/UF", ObjectHandle::string(b"b.txt".to_vec())),
(b"/EF", ef),
]);
set_test_object(&mut pdf, fs_b, fs_b_handle);
insert_embedded_file(&mut pdf, b"b.txt", fs_b).expect("insert b");
let removed = remove_attachment(&mut pdf, b"a.txt").expect("remove a");
assert!(removed);
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&fs_a),
"removed attachment's nulled filespec remains in memory"
);
assert!(
live.contains(&shared_stream),
"stream shared with another filespec must be preserved"
);
assert!(
live.contains(&fs_b),
"the other filespec sharing the stream must remain intact"
);
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 1);
let entries = list_embedded_files(&mut written).expect("list rewritten attachments");
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, b"b.txt");
}
#[test]
fn remove_attachment_gcs_all_distinct_ef_streams() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("multi.txt", b"primary stream")
.build(&mut pdf)
.expect("build filespec");
let filespec = resolved_handle(&mut pdf, fs_ref);
let ef = filespec.try_get_key(b"/EF").unwrap();
assert!(ef.as_dictionary().is_some(), "expected inline /EF dict");
let stream_f = ef
.try_get_key(b"/F")
.unwrap()
.object_ref()
.expect("expected /EF /F indirect stream");
let next = next_object_number(&mut pdf);
let stream_uf = ObjectRef::new(next + 1, 0);
let stream = ObjectHandle::stream(
handle_dictionary(vec![(
b"/Type",
ObjectHandle::name(b"EmbeddedFile".to_vec()),
)]),
std::rc::Rc::new(b"sibling stream".to_vec()),
);
set_test_object(&mut pdf, stream_uf, stream);
ef.replace_key(b"/UF", pdf.get_object_handle(stream_uf))
.expect("replace /EF /UF");
insert_embedded_file(&mut pdf, b"multi.txt", fs_ref).expect("insert");
let removed = remove_attachment(&mut pdf, b"multi.txt").expect("remove");
assert!(removed);
let live = pdf.canonical_live_object_refs();
assert!(live.contains(&fs_ref), "filespec remains in memory");
assert!(live.contains(&stream_f), "primary stream remains in memory");
assert!(
live.contains(&stream_uf),
"sibling stream remains in memory"
);
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 0);
assert!(list_embedded_files(&mut written)
.expect("list rewritten attachments")
.is_empty());
}
#[test]
fn remove_attachment_leaves_empty_indirect_af_array_intact() {
let mut pdf = open_minimal();
let next = next_object_number(&mut pdf);
let af_array_ref = ObjectRef::new(next + 1, 0);
set_test_object(&mut pdf, af_array_ref, handle_array(Vec::new()));
let sharer_ref = ObjectRef::new(next + 2, 0);
let sharer = handle_dictionary(vec![(b"/AF", pdf.get_object_handle(af_array_ref))]);
set_test_object(&mut pdf, sharer_ref, sharer);
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/AF", pdf.get_object_handle(af_array_ref))
.expect("replace catalog /AF");
catalog
.replace_key(b"/Sharer", pdf.get_object_handle(sharer_ref))
.expect("replace catalog /Sharer");
let fs_ref = FileSpecBuilder::new("x.txt", b"x")
.build(&mut pdf)
.expect("build");
insert_embedded_file(&mut pdf, b"x.txt", fs_ref).expect("insert");
let removed = remove_attachment(&mut pdf, b"x.txt").expect("remove");
assert!(removed);
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&af_array_ref),
"empty indirect /AF array (target absent) must NOT be deleted"
);
let catalog2 = catalog_handle(&mut pdf);
assert!(
catalog2.try_get_key(b"/AF").unwrap().object_ref() == Some(af_array_ref),
"catalog /AF must still point at the untouched indirect array"
);
}
#[test]
fn remove_nonexistent_key_returns_false() {
let mut pdf = open_minimal();
let dir = tempfile::tempdir().expect("tempdir");
let file = dir.path().join("keep.txt");
std::fs::write(&file, b"keep me").unwrap();
add_attachment_from_path(&mut pdf, b"keep.txt", &file).expect("add");
let result = remove_attachment(&mut pdf, b"no-such-key.txt").expect("no error");
assert!(!result, "must return false for absent key");
let entries = list_embedded_files(&mut pdf).expect("list");
assert_eq!(entries.len(), 1, "document must be unchanged");
assert_eq!(entries[0].0, b"keep.txt");
}
#[test]
fn remove_attachment_preserves_af_and_nulls_filespec_on_catalog_and_page() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("af-test.txt", b"payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"af-test.txt", fs_ref).expect("insert");
let catalog = catalog_handle(&mut pdf);
catalog
.replace_key(b"/AF", handle_array(vec![pdf.get_object_handle(fs_ref)]))
.expect("replace catalog /AF");
let page_refs = crate::pages::page_refs(&mut pdf).expect("page_refs");
assert_eq!(page_refs.len(), 1, "fixture has one page");
let page_ref = page_refs[0];
let page = resolved_handle(&mut pdf, page_ref);
page.replace_key(b"/AF", handle_array(vec![pdf.get_object_handle(fs_ref)]))
.expect("replace page /AF");
let removed = remove_attachment(&mut pdf, b"af-test.txt").expect("remove");
assert!(removed);
let catalog2 = catalog_handle(&mut pdf);
let catalog_af = catalog2
.try_get_key(b"/AF")
.unwrap()
.as_array()
.expect("catalog /AF");
assert_eq!(
catalog_af.len(),
1,
"qpdf keeps catalog /AF pointing at the nulled Filespec"
);
assert_eq!(catalog_af[0].object_ref(), Some(fs_ref));
assert!(
resolved_handle(&mut pdf, fs_ref).is_null(),
"qpdf replaces the removed Filespec with null"
);
let page_dict2 = resolved_handle(&mut pdf, page_ref);
let page_af = page_dict2
.try_get_key(b"/AF")
.unwrap()
.as_array()
.expect("page /AF");
assert_eq!(
page_af.len(),
1,
"qpdf keeps page /AF pointing at the nulled Filespec"
);
assert_eq!(page_af[0].object_ref(), Some(fs_ref));
}
#[test]
fn conservative_gc_preserves_shared_stream() {
let mut pdf = open_minimal();
let next = next_object_number(&mut pdf);
let stream_ref = ObjectRef::new(next + 1, 0);
let fs_ref1 = ObjectRef::new(next + 2, 0);
let fs_ref2 = ObjectRef::new(next + 3, 0);
let ef_dict = handle_dictionary(vec![
(b"/Type", ObjectHandle::name(b"EmbeddedFile".to_vec())),
(b"/Length", ObjectHandle::integer(7)),
]);
set_test_object(
&mut pdf,
stream_ref,
ObjectHandle::stream(ef_dict, std::rc::Rc::new(b"payload".to_vec())),
);
let ef_sub = handle_dictionary(vec![
(b"/F", pdf.get_object_handle(stream_ref)),
(b"/UF", pdf.get_object_handle(stream_ref)),
]);
let fs1 = handle_dictionary(vec![
(b"/Type", ObjectHandle::name(b"Filespec".to_vec())),
(b"/F", ObjectHandle::string(b"shared1.txt".to_vec())),
(b"/EF", ef_sub.clone()),
]);
set_test_object(&mut pdf, fs_ref1, fs1);
let fs2 = handle_dictionary(vec![
(b"/Type", ObjectHandle::name(b"Filespec".to_vec())),
(b"/F", ObjectHandle::string(b"shared2.txt".to_vec())),
(b"/EF", ef_sub),
]);
set_test_object(&mut pdf, fs_ref2, fs2);
insert_embedded_file(&mut pdf, b"shared1.txt", fs_ref1).expect("insert 1");
insert_embedded_file(&mut pdf, b"shared2.txt", fs_ref2).expect("insert 2");
let removed = remove_attachment(&mut pdf, b"shared1.txt").expect("remove");
assert!(removed);
let live = pdf.canonical_live_object_refs();
assert!(
live.contains(&stream_ref),
"shared stream must NOT be GC'd while fs_ref2 still references it"
);
assert!(
live.contains(&fs_ref1),
"removed filespec ref remains in memory before writer output"
);
assert!(
live.contains(&fs_ref2),
"surviving filespec ref must remain alive"
);
let mut written = rewritten(&mut pdf);
assert_eq!(count_embedded_file_streams(&mut written), 1);
let entries = list_embedded_files(&mut written).expect("list rewritten attachments");
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].0, b"shared2.txt");
}
#[test]
fn readers_return_empty_when_names_has_no_embedded_files() {
let mut pdf = open_minimal();
let names = handle_dictionary(vec![(b"/Dests", handle_dictionary(Vec::new()))]);
replace_catalog_key(&mut pdf, b"/Names", names);
assert!(
list_embedded_files(&mut pdf).expect("list").is_empty(),
"list_embedded_files must be empty when /EmbeddedFiles is absent"
);
assert!(
pdf.embedded_files()
.get_embedded_files()
.expect("handle-valued entries")
.is_empty(),
"handle-valued entries must be empty when /EmbeddedFiles is absent"
);
}
#[test]
fn handle_entries_preserve_direct_filespec_handles() {
let mut pdf = open_minimal();
let filespec = handle_dictionary(vec![
(b"/Type", ObjectHandle::name(b"Filespec".to_vec())),
(b"/F", ObjectHandle::string(b"direct.txt".to_vec())),
]);
let root = handle_dictionary(vec![(
b"/Names",
handle_array(vec![ObjectHandle::string(b"direct".to_vec()), filespec]),
)]);
let names = handle_dictionary(vec![(b"/EmbeddedFiles", root)]);
replace_catalog_key(&mut pdf, b"/Names", names);
let entries = pdf
.embedded_files()
.get_embedded_files()
.expect("collect direct filespec handle");
let filespec = entries
.get(b"direct".as_slice())
.expect("direct Filespec entry");
assert!(filespec.as_dictionary().is_some());
assert_eq!(
filespec.try_get_key(b"/F").unwrap().as_string(),
Some(b"direct.txt".to_vec())
);
}
#[test]
fn empty_remove_preserves_indirect_names_with_surviving_sibling() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("only.txt", b"only payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"only.txt", fs_ref).expect("insert");
let catalog = catalog_handle(&mut pdf);
let terminal = catalog
.try_get_key(b"/Names")
.unwrap()
.shallow_copy()
.expect("copy direct names");
terminal
.replace_key(
b"/Dests",
handle_dictionary(vec![(b"/X", pdf.get_object_handle(fs_ref))]),
)
.expect("add /Dests sibling");
let terminal_ref = ObjectRef::new(next_object_number(&mut pdf) + 1, 0);
set_test_object(&mut pdf, terminal_ref, terminal);
catalog
.replace_key(b"/Names", pdf.get_object_handle(terminal_ref))
.expect("install indirect Names");
let removed = remove_attachment(&mut pdf, b"only.txt").expect("remove only");
assert!(removed, "remove_attachment must return true");
let catalog_after = catalog_handle(&mut pdf);
let names_after = catalog_after
.try_get_key(b"/Names")
.unwrap()
.object_ref()
.expect("catalog /Names must still be indirect");
assert_eq!(names_after, terminal_ref);
let names_dict = resolved_handle(&mut pdf, terminal_ref);
assert!(
names_dict.try_has_key(b"/Dests").unwrap(),
"terminal /Names dict must retain the surviving /Dests sibling"
);
assert!(names_dict.try_has_key(b"/EmbeddedFiles").unwrap());
}
#[test]
fn non_empty_rebuild_with_direct_names_dict() {
let mut pdf = open_minimal();
let names = handle_dictionary(vec![(b"/Dests", handle_dictionary(Vec::new()))]);
replace_catalog_key(&mut pdf, b"/Names", names);
let fs_ref = FileSpecBuilder::new("direct.txt", b"direct payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"direct.txt", fs_ref).expect("insert");
let entries = list_embedded_files(&mut pdf).expect("list");
assert_eq!(entries.len(), 1, "attachment must be registered");
assert_eq!(entries[0].0, b"direct.txt");
let catalog_after = catalog_handle(&mut pdf);
let names_after = catalog_after
.try_get_key(b"/Names")
.unwrap()
.as_dictionary()
.expect("/Names direct after insert");
assert!(
names_after.contains_key(b"/Dests".as_slice()),
"the inline /Dests sibling must survive the rebuild"
);
assert!(
names_after.contains_key(b"/EmbeddedFiles".as_slice()),
"/EmbeddedFiles must be written into the /Names dict"
);
}
#[test]
fn empty_rebuild_with_direct_names_dict_and_sibling() {
let mut pdf = open_minimal();
let fs_ref = FileSpecBuilder::new("only2.txt", b"only2 payload")
.build(&mut pdf)
.expect("build filespec");
insert_embedded_file(&mut pdf, b"only2.txt", fs_ref).expect("insert");
let catalog = catalog_handle(&mut pdf);
let names = catalog
.try_get_key(b"/Names")
.unwrap()
.shallow_copy()
.expect("copy direct Names");
names
.replace_key(b"/Dests", handle_dictionary(Vec::new()))
.expect("add /Dests sibling");
catalog
.replace_key(b"/Names", names)
.expect("install direct Names");
let removed = remove_attachment(&mut pdf, b"only2.txt").expect("remove only2");
assert!(removed, "remove_attachment must return true");
let catalog_after = catalog_handle(&mut pdf);
let names_after = catalog_after
.try_get_key(b"/Names")
.unwrap()
.as_dictionary()
.expect("/Names must remain a direct dict");
assert!(
names_after.contains_key(b"/Dests".as_slice()),
"the /Dests sibling must survive the empty rebuild"
);
assert!(names_after.contains_key(b"/EmbeddedFiles".as_slice()));
}
}