use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use crate::object::{Dictionary, Object, ObjectRef};
use crate::ref_chain::terminal_ref_of_chain;
use crate::{Error, Pdf, Result};
const INHERITABLE_KEYS: [&[u8]; 4] = [b"CropBox", b"MediaBox", b"Resources", b"Rotate"];
const MAX_DEPTH: usize = crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH;
pub(crate) fn push_inherited_attributes_to_pages<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<()> {
let Some(root_ref) = pdf.root_ref() else {
return Ok(());
};
let Some(mut pages_ref) = (match pdf.resolve_borrowed(root_ref)? {
Object::Dictionary(d) => d.get_ref("Pages"),
_ => None,
}) else {
return Ok(());
};
let reconstructed = pdf
.repair_diagnostics()
.entries()
.iter()
.any(|d| d.message.contains("reconstruct cross-reference"));
if !reconstructed {
let mut seen_parent: BTreeSet<ObjectRef> = BTreeSet::new();
let mut corrected = pages_ref;
let mut changed_pages = false;
loop {
let parent = match pdf.resolve_borrowed(corrected)? {
Object::Dictionary(d) => match d.get("Parent") {
Some(Object::Reference(r)) => Some(*r),
_ => None,
},
_ => None, };
let Some(parent_ref) = parent else {
break;
};
if !seen_parent.insert(corrected) {
break; }
corrected = parent_ref;
changed_pages = true;
}
if changed_pages {
if let Object::Dictionary(mut root_dict) = pdf.resolve(root_ref)? {
root_dict.insert("Pages", Object::Reference(corrected));
pdf.set_object(root_ref, Object::Dictionary(root_dict));
}
pages_ref = corrected;
}
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut clone_visited: BTreeSet<ObjectRef> = BTreeSet::new();
let mut next_clone = next_object_ref(pdf)?;
repair_page_tree(
pdf,
pages_ref,
&mut seen,
&mut clone_visited,
&mut next_clone,
0,
false,
)?;
}
let mut key_ancestors: BTreeMap<&'static [u8], Vec<Object>> = BTreeMap::new();
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
push_internal(pdf, pages_ref, &mut key_ancestors, &mut visited, 0)?;
debug_assert!(
key_ancestors.values().all(Vec::is_empty),
"key_ancestors not empty after pushing inherited attributes to pages"
);
Ok(())
}
fn push_internal<R: Read + Seek>(
pdf: &mut Pdf<R>,
node_ref: ObjectRef,
key_ancestors: &mut BTreeMap<&'static [u8], Vec<Object>>,
visited: &mut BTreeSet<ObjectRef>,
depth: usize,
) -> Result<()> {
if depth >= MAX_DEPTH {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {MAX_DEPTH} at {node_ref}"
)));
}
if !visited.insert(node_ref) {
return Ok(());
}
let Object::Dictionary(mut dict) = pdf.resolve(node_ref)? else {
return Ok(()); };
let is_pages_node =
matches!(dict.get("Type"), Some(Object::Name(n)) if n.as_slice() == b"Pages");
if !is_pages_node {
return Ok(());
}
let mut own_keys: Vec<&'static [u8]> = Vec::new();
for &key in &INHERITABLE_KEYS {
let Some(value) = dict.remove(key) else {
continue;
};
let is_null = match &value {
Object::Null => true,
Object::Reference(r) => {
let terminal = terminal_ref_of_chain(pdf, *r)?;
matches!(pdf.resolve_borrowed(terminal)?, Object::Null)
}
_ => false,
};
if is_null {
dict.insert(key, value);
continue;
}
let value = match value {
Object::Reference(_) => value, Object::Array(_) | Object::Dictionary(_) => {
let new_ref = next_object_ref(pdf)?;
pdf.set_object(new_ref, value);
Object::Reference(new_ref)
}
scalar => scalar,
};
key_ancestors.entry(key).or_default().push(value);
own_keys.push(key);
}
let kids = dict
.get("Kids")
.and_then(Object::as_array)
.map(<[Object]>::to_vec);
pdf.set_object(node_ref, Object::Dictionary(dict));
if let Some(kids) = kids {
for kid in &kids {
let Object::Reference(kid_ref) = kid else {
continue;
};
let is_pages_node = matches!(
pdf.resolve_borrowed(*kid_ref)?,
Object::Dictionary(d)
if matches!(d.get("Type"), Some(Object::Name(n)) if n.as_slice() == b"Pages")
);
if is_pages_node {
push_internal(pdf, *kid_ref, key_ancestors, visited, depth + 1)?;
} else {
let Object::Dictionary(mut leaf) = pdf.resolve(*kid_ref)? else {
continue;
};
for (&key, values) in key_ancestors.iter() {
let leaf_value_is_present = match leaf.get(key) {
None | Some(Object::Null) => false,
Some(Object::Reference(r)) => {
let terminal = terminal_ref_of_chain(pdf, *r)?;
!matches!(pdf.resolve_borrowed(terminal)?, Object::Null)
}
Some(_) => true,
};
if !leaf_value_is_present {
if let Some(v) = values.last() {
leaf.insert(key, v.clone());
}
}
}
pdf.set_object(*kid_ref, Object::Dictionary(leaf));
}
}
}
for key in own_keys {
if let Some(stack) = key_ancestors.get_mut(key) {
stack.pop();
if stack.is_empty() {
key_ancestors.remove(key);
}
} }
Ok(())
}
fn repair_page_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node_ref: ObjectRef,
seen: &mut BTreeSet<ObjectRef>,
visited: &mut BTreeSet<ObjectRef>,
next_clone: &mut ObjectRef,
depth: usize,
media_box: bool,
) -> Result<()> {
if depth >= MAX_DEPTH {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {MAX_DEPTH} at {node_ref}"
)));
}
if !visited.insert(node_ref) {
return Ok(());
}
let Object::Dictionary(mut dict) = pdf.resolve(node_ref)? else {
return Ok(()); };
let Some(mut kids) = dict
.get("Kids")
.and_then(Object::as_array)
.map(<[Object]>::to_vec)
else {
return Ok(()); };
let mut changed = false;
if !type_name_is(&dict, b"Pages") {
dict.insert("Type", Object::Name(b"Pages".to_vec()));
changed = true;
}
let media_box = media_box || is_rectangle(pdf, dict.get("MediaBox"))?;
for kid in kids.iter_mut() {
let kid_ref = if let Object::Reference(r) = &*kid {
*r
} else if let Object::Dictionary(d) = &*kid {
if d.get("Kids").is_some() {
continue;
}
let new_ref = *next_clone;
let next_num = new_ref
.number
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
*next_clone = ObjectRef::new(next_num, 0);
let owned = std::mem::replace(kid, Object::Reference(new_ref));
pdf.set_object(new_ref, owned);
changed = true;
new_ref
} else {
continue; };
let (has_kids, leaf_media_box) = match pdf.resolve_borrowed(kid_ref)? {
Object::Dictionary(d) => (d.get("Kids").is_some(), d.get("MediaBox").cloned()),
_ => continue, };
if has_kids {
repair_page_tree(
pdf,
kid_ref,
seen,
visited,
next_clone,
depth + 1,
media_box,
)?;
continue;
}
if !media_box && !is_rectangle(pdf, leaf_media_box.as_ref())? {
if let Object::Dictionary(mut leaf) = pdf.resolve(kid_ref)? {
leaf.insert(
"MediaBox",
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
]),
);
pdf.set_object(kid_ref, Object::Dictionary(leaf));
}
}
let leaf_ref = if seen.insert(kid_ref) {
kid_ref } else {
let clone = pdf.resolve(kid_ref)?; let new_ref = *next_clone;
let next_num = new_ref
.number
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
*next_clone = ObjectRef::new(next_num, 0);
pdf.set_object(new_ref, clone);
seen.insert(new_ref);
*kid = Object::Reference(new_ref);
changed = true;
new_ref
};
let wrong_type = matches!(
pdf.resolve_borrowed(leaf_ref)?,
Object::Dictionary(d) if !type_name_is(d, b"Page")
);
if wrong_type {
if let Object::Dictionary(mut leaf) = pdf.resolve(leaf_ref)? {
leaf.insert("Type", Object::Name(b"Page".to_vec()));
pdf.set_object(leaf_ref, Object::Dictionary(leaf));
}
}
}
if changed {
dict.insert("Kids", Object::Array(kids));
pdf.set_object(node_ref, Object::Dictionary(dict));
}
Ok(())
}
fn next_object_ref<R: Read + Seek>(pdf: &Pdf<R>) -> Result<ObjectRef> {
let n = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
Ok(ObjectRef::new(n, 0))
}
fn type_name_is(dict: &Dictionary, want: &[u8]) -> bool {
matches!(dict.get("Type"), Some(Object::Name(n)) if n.as_slice() == want)
}
fn is_rectangle<R: Read + Seek>(pdf: &mut Pdf<R>, value: Option<&Object>) -> Result<bool> {
let items: Vec<Object> = match value {
None => return Ok(false),
Some(Object::Reference(r)) => {
let terminal = terminal_ref_of_chain(pdf, *r)?;
match pdf.resolve_borrowed(terminal)? {
Object::Array(items) if items.len() == 4 => items.clone(),
_ => return Ok(false),
}
}
Some(Object::Array(items)) if items.len() == 4 => items.clone(),
Some(_) => return Ok(false),
};
for e in &items {
let is_num = match e {
Object::Integer(_) | Object::Real(_) => true,
Object::Reference(r) => {
let terminal = terminal_ref_of_chain(pdf, *r)?;
let resolved = pdf.resolve_borrowed(terminal)?;
matches!(resolved, Object::Integer(_) | Object::Real(_))
}
_ => false,
};
if !is_num {
return Ok(false);
}
}
Ok(true)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Pdf;
use std::io::Cursor;
fn pdf_with_no_inheritable_keys() -> 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;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn no_inheritable_keys_is_a_no_op() {
let bytes = pdf_with_no_inheritable_keys();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count,
"no inheritable keys present anywhere: no object should be minted"
);
let page = pdf.resolve(ObjectRef::new(3, 0)).expect("page resolves");
let Object::Dictionary(page_dict) = page else {
panic!("page is not a dictionary"); };
assert!(
page_dict.get("MediaBox").is_some(),
"the page's own /MediaBox must be untouched"
);
}
fn pdf_with_inherited_scalar_rotate() -> 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 /Rotate 90 >>\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;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn scalar_rotate_is_copied_by_value_not_minted() {
let bytes = pdf_with_inherited_scalar_rotate();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count,
"a scalar inherited value must never mint a new object"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("pages is not a dictionary"); };
assert!(
pages_dict.get("Rotate").is_none(),
"/Rotate must be stripped from the interior /Pages node"
);
let page = pdf.resolve(ObjectRef::new(3, 0)).expect("page resolves");
let Object::Dictionary(page_dict) = page else {
panic!("page is not a dictionary"); };
assert_eq!(
page_dict.get("Rotate"),
Some(&Object::Integer(90)),
"/Rotate must be pushed to the leaf as a direct (literal) value"
);
}
fn pdf_with_inherited_direct_resources() -> 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 \
/Resources << /Font << /F1 4 0 R >> >> >>\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<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn direct_non_scalar_resources_is_minted_as_new_object() {
let bytes = pdf_with_inherited_direct_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count + 1,
"a direct non-scalar inherited value must mint exactly one new object"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("pages is not a dictionary"); };
assert!(
pages_dict.get("Resources").is_none(),
"/Resources must be stripped from the interior /Pages node"
);
let page = pdf.resolve(ObjectRef::new(3, 0)).expect("page resolves");
let Object::Dictionary(page_dict) = page else {
panic!("page is not a dictionary"); };
let Some(Object::Reference(resources_ref)) = page_dict.get("Resources") else {
panic!("/Resources must be pushed to the leaf as an indirect reference, not inline");
};
assert_eq!(
resources_ref.number, 5,
"the minted object must be the next free object number (4 was already in use)"
);
let minted = pdf.resolve(*resources_ref).expect("minted object resolves");
let Object::Dictionary(minted_dict) = minted else {
panic!("minted object is not a dictionary"); };
assert!(
minted_dict.get("Font").is_some(),
"the minted object must carry the original /Resources content"
);
}
fn pdf_with_two_direct_non_scalar_keys_on_one_node() -> 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 \
/CropBox [0 0 100 100] /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Page /Parent 2 0 R >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn multiple_direct_non_scalar_keys_mint_in_qpdf_alphabetical_order() {
let bytes = pdf_with_two_direct_non_scalar_keys_on_one_node();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
let Some(Object::Reference(crop_ref)) = leaf_dict.get("CropBox") else {
panic!("/CropBox must be pushed as an indirect reference"); };
let Some(Object::Reference(media_ref)) = leaf_dict.get("MediaBox") else {
panic!("/MediaBox must be pushed as an indirect reference"); };
assert!(
crop_ref.number < media_ref.number,
"/CropBox must mint before /MediaBox (qpdf's alphabetical getKeys() \
order), got CropBox={crop_ref} MediaBox={media_ref}"
);
}
fn pdf_with_already_indirect_resources_shared_by_two_pages() -> 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 5 0 R] /Count 2 /Resources 4 0 R >>\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<< /Font << /F1 6 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn already_indirect_value_is_shared_not_reminted() {
let bytes = pdf_with_already_indirect_resources_shared_by_two_pages();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count,
"an already-indirect inherited value must never be re-minted"
);
for page_num in [3u32, 5] {
let page = pdf
.resolve(ObjectRef::new(page_num, 0))
.unwrap_or_else(|e| panic!("page {page_num} resolves: {e}"));
let Object::Dictionary(page_dict) = page else {
panic!("page {page_num} is not a dictionary"); };
assert_eq!(
page_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(4, 0))),
"page {page_num} must share the original object 4, not a copy"
);
}
}
fn pdf_with_leaf_local_resources_override() -> 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 /Resources 4 0 R >>\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] \
/Resources 5 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font << /F1 6 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Font << /F2 6 0 R >> >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn leaf_local_value_is_never_overwritten() {
let bytes = pdf_with_leaf_local_resources_override();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let page = pdf.resolve(ObjectRef::new(3, 0)).expect("page resolves");
let Object::Dictionary(page_dict) = page else {
panic!("page is not a dictionary"); };
assert_eq!(
page_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(5, 0))),
"the leaf's own /Resources (5 0 R) must NOT be replaced by the \
ancestor's (4 0 R)"
);
}
fn pdf_with_three_level_nearest_ancestor_wins() -> 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 /Resources 4 0 R >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [6 0 R] /Count 1 \
/Resources 5 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font << /F1 7 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Font << /F2 7 0 R >> >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off7 = pdf.len() as u64;
pdf.extend_from_slice(
b"7 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 8\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off7:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn nearest_ancestor_value_wins_in_three_level_tree() {
let bytes = pdf_with_three_level_nearest_ancestor_wins();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(6, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(5, 0))),
"the leaf must inherit the NEAREST ancestor's /Resources (5 0 R, \
from the parent /Pages), not the grandparent's (4 0 R)"
);
let grandparent = pdf
.resolve(ObjectRef::new(2, 0))
.expect("grandparent resolves");
let Object::Dictionary(gp_dict) = grandparent else {
panic!("grandparent is not a dictionary"); };
assert!(gp_dict.get("Resources").is_none());
let parent = pdf.resolve(ObjectRef::new(3, 0)).expect("parent resolves");
let Object::Dictionary(parent_dict) = parent else {
panic!("parent is not a dictionary"); };
assert!(parent_dict.get("Resources").is_none());
}
fn pdf_with_self_referential_pages_node() -> 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 [2 0 R 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;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn self_referential_pages_node_terminates() {
let bytes = pdf_with_self_referential_pages_node();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a self-referential /Kids entry must be skipped, not error"
);
}
fn pdf_with_non_dictionary_pages_root() -> 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\n42\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 3\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn non_dictionary_pages_root_is_a_no_op() {
let bytes = pdf_with_non_dictionary_pages_root();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a non-dictionary /Pages root must be a no-op, not an error: {result:?}"
);
}
fn pdf_without_root() -> 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 >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 2\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
#[test]
fn missing_root_is_a_no_op() {
let bytes = pdf_without_root();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF even without /Root");
assert!(
pdf.root_ref().is_none(),
"fixture must have no /Root for this test to be meaningful"
);
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a document with no /Root must be a no-op, not an error: {result:?}"
);
}
fn pdf_with_non_dictionary_root() -> 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\n42\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 2\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn non_dictionary_root_is_a_no_op() {
let bytes = pdf_with_non_dictionary_root();
let mut pdf =
Pdf::open(Cursor::new(bytes)).expect("valid PDF even with a non-dictionary /Root");
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a non-dictionary /Root must be a no-op, not an error: {result:?}"
);
}
fn pdf_with_root_missing_pages_key() -> 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 >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 2\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn root_dict_without_pages_key_is_a_no_op() {
let bytes = pdf_with_root_missing_pages_key();
let mut pdf =
Pdf::open(Cursor::new(bytes)).expect("valid PDF even with /Root lacking /Pages");
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a /Root dictionary with no /Pages key must be a no-op, not an error: {result:?}"
);
}
fn pdf_with_pages_node_missing_kids() -> 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 /Count 0 /Rotate 90 >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 3\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn pages_node_without_kids_is_a_no_op_not_a_panic() {
let bytes = pdf_with_pages_node_missing_kids();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a /Pages node without /Kids must be a no-op, not an error: {result:?}"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
assert!(
matches!(&pages, Object::Dictionary(d) if d.get("Rotate").is_none()),
"/Rotate must still be stripped from the /Pages node even with no \
/Kids to push it to: {pages:?}"
);
}
fn pdf_with_malformed_kids_entries() -> 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 [42 3 0 R 4 0 R] /Count 1 /Rotate 90 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n(not a dictionary)\nendobj\n");
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn malformed_kids_entries_are_skipped_valid_leaf_still_pushed() {
let bytes = pdf_with_malformed_kids_entries();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Rotate"),
Some(&Object::Integer(90)),
"the one valid leaf must still receive the inherited /Rotate despite \
the malformed sibling entries in /Kids"
);
}
fn pdf_with_excessive_pages_depth() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let depth = MAX_DEPTH + 1;
let leaf_num = 2 + depth as u32;
let mut offsets: Vec<u64> = Vec::with_capacity(1 + depth + 1);
offsets.push(pdf.len() as u64);
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
for level in 0..depth {
let this_num = 2 + level as u32;
let next_ref = if level + 1 == depth {
leaf_num
} else {
this_num + 1
};
offsets.push(pdf.len() as u64);
pdf.extend_from_slice(
format!(
"{this_num} 0 obj\n<< /Type /Pages /Kids [{next_ref} 0 R] /Count 1 >>\nendobj\n"
)
.as_bytes(),
);
}
offsets.push(pdf.len() as u64);
pdf.extend_from_slice(
format!(
"{leaf_num} 0 obj\n<< /Type /Page /Parent {} 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
leaf_num - 1
)
.as_bytes(),
);
let total = offsets.len() + 1; let xref_start = pdf.len() as u64;
pdf.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
pdf.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn excessive_depth_returns_unsupported_error() {
let bytes = pdf_with_excessive_pages_depth();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
matches!(result, Err(Error::Unsupported(_))),
"a /Pages tree deeper than MAX_DEPTH must error, not stack-overflow: {result:?}"
);
}
fn pdf_with_leaf_direct_scalar_override() -> 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 /Rotate 90 >>\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] \
/Rotate 270 >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn leaf_direct_scalar_override_is_never_overwritten() {
let bytes = pdf_with_leaf_direct_scalar_override();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Rotate"),
Some(&Object::Integer(270)),
"the leaf's own direct (non-reference, non-null) /Rotate must win \
over the ancestor's /Rotate 90"
);
}
fn pdf_with_leaf_direct_null_resources() -> 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 /Resources 4 0 R >>\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] \
/Resources null >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font << /F1 5 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn explicit_null_leaf_value_is_treated_as_absent() {
let bytes = pdf_with_leaf_direct_null_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(4, 0))),
"a direct null /Resources on the leaf must be treated as absent \
and replaced by the inherited value, not left as null"
);
}
fn pdf_with_leaf_indirect_null_resources() -> 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 /Resources 4 0 R >>\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] \
/Resources 6 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font << /F1 5 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\nnull\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn indirect_reference_resolving_to_null_is_treated_as_absent() {
let bytes = pdf_with_leaf_indirect_null_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(4, 0))),
"an indirect /Resources reference resolving to null must be treated \
as absent and replaced by the inherited value"
);
}
fn pdf_with_leaf_multi_hop_null_resources() -> 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 /Resources 4 0 R >>\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] \
/Resources 6 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font << /F1 5 0 R >> >>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n7 0 R\nendobj\n");
let off7 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\nnull\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 8\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off7:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn leaf_multi_hop_null_reference_chain_is_treated_as_absent() {
let bytes = pdf_with_leaf_multi_hop_null_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(4, 0))),
"a /Resources reaching null through a two-hop reference chain \
(6 0 R -> 7 0 R -> null) must be treated as absent and replaced \
by the inherited value, not just a single-hop null"
);
}
fn pdf_with_page_typed_root_pages() -> 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 /Page /MediaBox [0 0 612 792] >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 3\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn page_typed_root_pages_keeps_its_own_attributes() {
let bytes = pdf_with_page_typed_root_pages();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed, not error");
assert_eq!(
pdf.object_refs().len(),
before_count,
"no object should be minted when the root itself is not a /Pages node"
);
let root_page = pdf
.resolve(ObjectRef::new(2, 0))
.expect("root page resolves");
let Object::Dictionary(root_page_dict) = root_page else {
panic!("root page is not a dictionary"); };
assert_eq!(
root_page_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"/MediaBox must NOT be stripped from a /Page reached as the (malformed) \
/Root/Pages entry, since it has no /Kids to push the value to"
);
}
fn pdf_with_ancestor_direct_null_resources() -> 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 /Resources 5 0 R >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 \
/Resources null >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Font << /F1 6 0 R >> >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn ancestor_direct_null_value_does_not_shadow_grandparent() {
let bytes = pdf_with_ancestor_direct_null_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let child = pdf.resolve(ObjectRef::new(3, 0)).expect("child resolves");
let Object::Dictionary(child_dict) = child else {
panic!("child is not a dictionary"); };
assert_eq!(
child_dict.get("Resources"),
Some(&Object::Null),
"a null-valued /Resources on the child /Pages node must be left \
in place, not erased — it is invisible to qpdf's getKeys(), so \
qpdf's loop never touches it"
);
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(5, 0))),
"the leaf must inherit the GRANDPARENT's real /Resources, not be \
shadowed by the child's null"
);
}
fn pdf_with_ancestor_indirect_null_resources() -> 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 /Resources 5 0 R >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 \
/Resources 7 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Font << /F1 6 0 R >> >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let off7 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\nnull\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 8\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off7:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 8 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn ancestor_indirect_null_value_does_not_shadow_grandparent() {
let bytes = pdf_with_ancestor_indirect_null_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let child = pdf.resolve(ObjectRef::new(3, 0)).expect("child resolves");
let Object::Dictionary(child_dict) = child else {
panic!("child is not a dictionary"); };
assert_eq!(
child_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(7, 0))),
"an indirect /Resources reference resolving to null on the child \
/Pages node must be left in place, not erased"
);
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(5, 0))),
"the leaf must inherit the GRANDPARENT's real /Resources, not be \
shadowed by the child's indirect-null value"
);
}
fn pdf_with_ancestor_multi_hop_null_resources() -> 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 /Resources 5 0 R >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 \
/Resources 7 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< /Font << /F1 6 0 R >> >>\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"6 0 obj\n<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>\nendobj\n",
);
let off7 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\n8 0 R\nendobj\n");
let off8 = pdf.len() as u64;
pdf.extend_from_slice(b"8 0 obj\nnull\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 9\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off7:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off8:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 9 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn ancestor_multi_hop_null_reference_chain_does_not_shadow_grandparent() {
let bytes = pdf_with_ancestor_multi_hop_null_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let child = pdf.resolve(ObjectRef::new(3, 0)).expect("child resolves");
let Object::Dictionary(child_dict) = child else {
panic!("child is not a dictionary"); };
assert_eq!(
child_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(7, 0))),
"a /Resources reaching null through a two-hop reference chain on \
the child /Pages node must be left in place, not erased"
);
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Resources"),
Some(&Object::Reference(ObjectRef::new(5, 0))),
"the leaf must inherit the GRANDPARENT's real /Resources, not be \
shadowed by the child's two-hop null reference chain"
);
}
fn pdf_with_leaf_shared_by_two_parents() -> 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 4 0 R] /Count 2 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [5 0 R] /Count 1 /Rotate 90 >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [5 0 R] /Count 1 /Rotate 180 >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] \
/Contents 6 0 R >>\nendobj\n",
);
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn duplicate_leaf_across_two_parents_is_cloned() {
let bytes = pdf_with_leaf_shared_by_two_parents();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count + 1,
"a leaf shared by two parents must mint exactly one clone"
);
let a = pdf.resolve(ObjectRef::new(3, 0)).expect("A resolves");
let Object::Dictionary(a_dict) = a else {
panic!("A not a dict") };
assert_eq!(
a_dict.get("Kids"),
Some(&Object::Array(vec![Object::Reference(ObjectRef::new(
5, 0
))])),
"parent A must keep the original leaf 5 in its /Kids"
);
let b = pdf.resolve(ObjectRef::new(4, 0)).expect("B resolves");
let Object::Dictionary(b_dict) = b else {
panic!("B not a dict") };
assert_eq!(
b_dict.get("Kids"),
Some(&Object::Array(vec![Object::Reference(ObjectRef::new(
7, 0
))])),
"parent B's /Kids entry must be rewritten to the clone (7)"
);
let leaf = pdf.resolve(ObjectRef::new(5, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf not a dict") };
assert_eq!(leaf_dict.get("Rotate"), Some(&Object::Integer(90)));
let clone = pdf.resolve(ObjectRef::new(7, 0)).expect("clone resolves");
let Object::Dictionary(clone_dict) = clone else {
panic!("clone not a dict") };
assert_eq!(
clone_dict.get("Rotate"),
Some(&Object::Integer(180)),
"the clone must inherit parent B's /Rotate 180 independently — a naive \
skip would drop it"
);
assert_eq!(
clone_dict.get("Parent"),
Some(&Object::Reference(ObjectRef::new(3, 0))),
"the clone must keep the original leaf's /Parent (A), not be re-pointed to B"
);
assert_eq!(
leaf_dict.get("Contents"),
Some(&Object::Reference(ObjectRef::new(6, 0)))
);
assert_eq!(
clone_dict.get("Contents"),
Some(&Object::Reference(ObjectRef::new(6, 0))),
"shallowCopy keeps indirect sub-objects (/Contents) shared, not duplicated"
);
let root_pages = pdf
.resolve(ObjectRef::new(2, 0))
.expect("root pages resolves");
let Object::Dictionary(rp) = root_pages else {
panic!("root pages not a dict") };
assert_eq!(
rp.get("Count"),
Some(&Object::Integer(2)),
"/Count must be unchanged"
);
}
fn pdf_with_leaf_listed_twice() -> 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 3 0 R] /Count 2 >>\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;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn leaf_listed_twice_in_one_parent_is_cloned() {
let bytes = pdf_with_leaf_listed_twice();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count + 1,
"one clone minted"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("not a dict") };
assert_eq!(
pages_dict.get("Kids"),
Some(&Object::Array(vec![
Object::Reference(ObjectRef::new(3, 0)),
Object::Reference(ObjectRef::new(4, 0)),
])),
"the second occurrence must be rewritten to the clone (4), first kept as 3"
);
}
fn pdf_with_leaf_listed_thrice() -> 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 3 0 R 3 0 R] /Count 3 >>\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;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn leaf_appearing_three_times_mints_two_clones() {
let bytes = pdf_with_leaf_listed_thrice();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count + 2,
"two clones minted"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("not a dict") };
assert_eq!(
pages_dict.get("Kids"),
Some(&Object::Array(vec![
Object::Reference(ObjectRef::new(3, 0)),
Object::Reference(ObjectRef::new(4, 0)),
Object::Reference(ObjectRef::new(5, 0)),
])),
"3x occurrence must become three distinct refs [3, clone 4, clone 5]"
);
}
fn pdf_with_two_distinct_pages() -> 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 4 0 R] /Count 2 >>\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<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn no_duplicate_leaf_mints_nothing() {
let bytes = pdf_with_two_distinct_pages();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count,
"a tree with no shared leaf must mint nothing (the clone pass is a no-op)"
);
}
#[test]
fn clone_pass_is_idempotent() {
let bytes = pdf_with_leaf_shared_by_two_parents();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("first push");
let after_first = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("second push");
assert_eq!(
pdf.object_refs().len(),
after_first,
"re-running the pass must not clone again (no leaf appears twice after \
the first run)"
);
}
fn pdf_shared_leaf_damaged_xref() -> Vec<u8> {
let mut bytes = pdf_with_leaf_shared_by_two_parents();
let needle = b"startxref\n";
let pos = bytes
.windows(needle.len())
.position(|w| w == needle)
.expect("fixture has startxref");
let num_start = pos + needle.len();
let num_end = bytes[num_start..]
.iter()
.position(|&b| b == b'\n')
.map(|i| num_start + i)
.expect("startxref value ends in newline");
bytes.splice(num_start..num_end, b"9".to_vec());
bytes
}
#[test]
fn reconstructed_xref_input_does_not_clone() {
let bytes = pdf_shared_leaf_damaged_xref();
let mut pdf = Pdf::open_with_repair(Cursor::new(bytes)).expect("recovers");
assert!(
pdf.repair_diagnostics()
.entries()
.iter()
.any(|d| d.message.contains("reconstruct cross-reference")),
"fixture must actually reconstruct its xref for this test to be meaningful"
);
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count,
"a reconstructed-xref input must NOT clone the shared leaf (qpdf gates \
the clone arm on !reconstructed_xref)"
);
}
fn pdf_with_interior_type_not_pages() -> 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 /Foo /Parent 2 0 R /Kids [4 0 R] /Count 1 /Rotate 90 >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn interior_type_not_pages_is_overridden() {
let bytes = pdf_with_interior_type_not_pages();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else the repair pass is \
skipped behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let interior = pdf
.resolve(ObjectRef::new(3, 0))
.expect("interior resolves");
let Object::Dictionary(interior_dict) = interior else {
panic!("interior is not a dictionary"); };
assert_eq!(
interior_dict.get("Type"),
Some(&Object::Name(b"Pages".to_vec())),
"the interior node's mistyped /Type /Foo must be overridden to /Pages"
);
assert!(
interior_dict.get("Rotate").is_none(),
"/Rotate must be stripped from the now-correctly-typed interior /Pages node"
);
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Rotate"),
Some(&Object::Integer(90)),
"/Rotate must be pushed to the leaf — proving the interior override \
let the push recognise the node as a /Pages node"
);
}
fn pdf_with_leaf_type_not_page() -> 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 /Bar /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn leaf_type_not_page_is_overridden() {
let bytes = pdf_with_leaf_type_not_page();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Type"),
Some(&Object::Name(b"Page".to_vec())),
"the leaf's mistyped /Type /Bar must be overridden to /Page"
);
}
#[test]
fn correct_types_unchanged_no_mint() {
let bytes = pdf_with_no_inheritable_keys();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count,
"a correctly-typed tree must not mint any object"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("pages is not a dictionary"); };
assert_eq!(
pages_dict.get("Type"),
Some(&Object::Name(b"Pages".to_vec())),
"an already-correct interior /Type must be left untouched"
);
let page = pdf.resolve(ObjectRef::new(3, 0)).expect("page resolves");
let Object::Dictionary(page_dict) = page else {
panic!("page is not a dictionary"); };
assert_eq!(
page_dict.get("Type"),
Some(&Object::Name(b"Page".to_vec())),
"an already-correct leaf /Type must be left untouched"
);
}
fn pdf_with_missing_types() -> 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<< /Parent 2 0 R /Kids [4 0 R] /Count 1 >>\nendobj\n");
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn type_missing_is_set() {
let bytes = pdf_with_missing_types();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let interior = pdf
.resolve(ObjectRef::new(3, 0))
.expect("interior resolves");
let Object::Dictionary(interior_dict) = interior else {
panic!("interior is not a dictionary"); };
assert_eq!(
interior_dict.get("Type"),
Some(&Object::Name(b"Pages".to_vec())),
"an interior node with no /Type must have /Type set to /Pages"
);
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Type"),
Some(&Object::Name(b"Page".to_vec())),
"a leaf with no /Type must have /Type set to /Page"
);
}
fn pdf_with_missing_mediabox_leaf() -> 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 >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn missing_mediabox_leaf_gets_default() {
let bytes = pdf_with_missing_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else the repair pass is \
skipped behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"a leaf with no /MediaBox and no ancestor /MediaBox must get the \
letter/ANSI A default [0 0 612 792] as a direct 4-integer array"
);
}
fn pdf_with_ancestor_mediabox_no_leaf_mediabox() -> 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 /MediaBox [0 0 200 300] >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Type /Page /Parent 3 0 R >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn ancestor_mediabox_suppresses_default() {
let bytes = pdf_with_ancestor_mediabox_no_leaf_mediabox();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(4, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
let mb_ref = leaf_dict
.get_ref("MediaBox")
.expect("leaf must inherit the ancestor /MediaBox as an indirect reference");
let media_box = pdf.resolve(mb_ref).expect("/MediaBox ref resolves");
assert_eq!(
media_box,
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(200),
Object::Integer(300),
]),
"the leaf must inherit the ancestor /MediaBox [0 0 200 300], NOT the \
[0 0 612 792] default — inheritance wins, the default is suppressed"
);
}
fn pdf_with_invalid_mediabox_leaf() -> 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] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn invalid_mediabox_leaf_gets_default() {
let bytes = pdf_with_invalid_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"a leaf whose /MediaBox is not a 4-number array must be replaced with \
the [0 0 612 792] default"
);
}
fn pdf_with_valid_mediabox_leaf() -> 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 100 100] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn valid_mediabox_leaf_unchanged() {
let bytes = pdf_with_valid_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(100),
Object::Integer(100),
])),
"a leaf with an already-valid /MediaBox must be left unchanged (no default)"
);
}
fn pdf_with_indirect_reference_mediabox_leaf() -> 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 4 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n[0 0 300 400]\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn indirect_reference_mediabox_leaf_is_recognized_and_not_defaulted() {
let bytes = pdf_with_indirect_reference_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Reference(ObjectRef::new(4, 0))),
"a leaf whose /MediaBox is an indirect reference to a valid rectangle \
must be recognized as a rectangle and left as the reference (no default)"
);
}
fn pdf_with_indirect_element_mediabox_leaf() -> 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 4 0 R] >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n792\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn indirect_element_mediabox_leaf_is_recognized_and_not_defaulted() {
let bytes = pdf_with_indirect_element_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Reference(ObjectRef::new(4, 0)),
])),
"a /MediaBox array whose element is an indirect reference to a number \
is a valid rectangle (qpdf dereferences it) and must be left unchanged"
);
}
fn pdf_with_reference_non_rectangle_mediabox_leaf() -> 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 4 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n[0 0 300]\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn reference_non_rectangle_mediabox_leaf_gets_default() {
let bytes = pdf_with_reference_non_rectangle_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"a /MediaBox that is an indirect reference to a non-rectangle must be \
replaced with the [0 0 612 792] default"
);
}
fn pdf_with_shared_leaf_mediabox_default() -> 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 4 0 R] /Count 2 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [5 0 R] /Count 1 \
/MediaBox [0 0 200 300] >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Pages /Parent 2 0 R /Kids [5 0 R] /Count 1 >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<< /Type /Page /Parent 3 0 R /Contents 6 0 R >>\nendobj\n",
);
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 7\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off6:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 7 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn shared_leaf_mediabox_default_before_clone_ordering() {
let bytes = pdf_with_shared_leaf_mediabox_default();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let b = pdf.resolve(ObjectRef::new(4, 0)).expect("B resolves");
let Object::Dictionary(b_dict) = b else {
panic!("B not a dict") };
assert_eq!(
b_dict.get("Kids"),
Some(&Object::Array(vec![Object::Reference(ObjectRef::new(
7, 0
))])),
"parent B's /Kids entry must be rewritten to the clone (7)"
);
let default_box = Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
]));
let leaf = pdf.resolve(ObjectRef::new(5, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf not a dict") };
assert_eq!(
leaf_dict.get("MediaBox"),
default_box,
"the shared original (A's page) must be defaulted to [0 0 612 792] on \
the B visit, not keep A's inherited [0 0 200 300] (default-before-clone)"
);
let clone = pdf.resolve(ObjectRef::new(7, 0)).expect("clone resolves");
let Object::Dictionary(clone_dict) = clone else {
panic!("clone not a dict") };
assert_eq!(
clone_dict.get("MediaBox"),
default_box,
"the clone (B's page) must inherit the defaulted [0 0 612 792]"
);
assert_eq!(
clone_dict.get("Parent"),
Some(&Object::Reference(ObjectRef::new(3, 0))),
"the clone must keep the original leaf's /Parent (A)"
);
}
fn pdf_with_non_numeric_mediabox_leaf() -> 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 /Foo] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn non_numeric_mediabox_element_gets_default() {
let bytes = pdf_with_non_numeric_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"a /MediaBox array with a non-numeric element is not a rectangle and \
must be replaced with the [0 0 612 792] default"
);
}
fn pdf_with_real_mediabox_leaf() -> 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 0.0 612.0 792.0] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn real_mediabox_leaf_is_recognized_and_not_defaulted() {
let bytes = pdf_with_real_mediabox_leaf();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf.resolve(ObjectRef::new(3, 0)).expect("leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Real(0.0),
Object::Real(0.0),
Object::Real(612.0),
Object::Real(792.0),
])),
"a /MediaBox of four Real values is a valid rectangle and must be left \
unchanged (no default)"
);
}
fn pdf_with_direct_leaf_kid() -> 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 [<< /Type /Page \
/MediaBox [0 0 612 792] /Contents 3 0 R >>] /Count 1 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn direct_leaf_kid_is_made_indirect() {
let bytes = pdf_with_direct_leaf_kid();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else the repair pass is \
skipped behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
let before_count = pdf.object_refs().len();
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
assert_eq!(
pdf.object_refs().len(),
before_count + 1,
"the direct leaf must be minted into exactly one new indirect object"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("pages is not a dictionary"); };
assert_eq!(
pages_dict.get("Kids"),
Some(&Object::Array(vec![Object::Reference(ObjectRef::new(
4, 0
))])),
"/Kids[0] must be rewritten to an indirect reference to the minted leaf (4)"
);
let leaf = pdf
.resolve(ObjectRef::new(4, 0))
.expect("minted leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("minted leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("Type"),
Some(&Object::Name(b"Page".to_vec())),
"the minted leaf must keep /Type /Page"
);
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"the minted leaf must keep its own /MediaBox"
);
assert_eq!(
leaf_dict.get("Contents"),
Some(&Object::Reference(ObjectRef::new(3, 0))),
"the minted leaf must preserve its /Contents reference"
);
assert_eq!(
leaf_dict.get("Parent"),
None,
"the minted leaf must not gain a synthesized /Parent (makeIndirectObject adds none)"
);
}
fn pdf_with_direct_leaf_kid_no_mediabox() -> 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 [<< /Type /Page \
/Contents 3 0 R >>] /Count 1 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn direct_leaf_without_mediabox_minted_object_gets_default() {
let bytes = pdf_with_direct_leaf_kid_no_mediabox();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else the repair pass is \
skipped behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let leaf = pdf
.resolve(ObjectRef::new(4, 0))
.expect("minted leaf resolves");
let Object::Dictionary(leaf_dict) = leaf else {
panic!("minted leaf is not a dictionary"); };
assert_eq!(
leaf_dict.get("MediaBox"),
Some(&Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
])),
"the minted indirect leaf must carry the [0 0 612 792] default \
(default-before-makeIndirectObject ordering)"
);
}
fn pdf_with_direct_interior_node() -> 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 [<< /Type /Pages \
/Kids [3 0 R] /Count 1 >>] /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] \
/Contents 4 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn direct_interior_node_is_skipped() {
let bytes = pdf_with_direct_interior_node();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction: {:?}",
pdf.repair_diagnostics().entries(), );
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a direct interior node must be skipped, not panic or error: {result:?}"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("pages is not a dictionary"); };
let Some(Object::Array(kids)) = pages_dict.get("Kids") else {
panic!("/Kids must still be an array"); };
assert!(
matches!(kids.first(), Some(Object::Dictionary(_))),
"the direct interior node must stay a direct dict (out-of-scope, not minted)"
);
}
fn pdf_with_direct_scalar_kid() -> 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 [42] /Count 1 >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 3\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 3 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn direct_non_dictionary_kid_is_skipped() {
let bytes = pdf_with_direct_scalar_kid();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
let before_count = pdf.object_refs().len();
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a direct non-dictionary /Kids entry must be skipped, not panic or error: {result:?}"
);
assert_eq!(
pdf.object_refs().len(),
before_count,
"a direct non-dictionary /Kids entry must never mint an object"
);
let pages = pdf.resolve(ObjectRef::new(2, 0)).expect("pages resolves");
let Object::Dictionary(pages_dict) = pages else {
panic!("pages is not a dictionary"); };
assert_eq!(
pages_dict.get("Kids"),
Some(&Object::Array(vec![Object::Integer(42)])),
"the scalar /Kids entry must stay a direct integer (not minted to a ref)"
);
}
fn pdf_with_root_pages_pointing_into_tree() -> 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 3 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] \
/Contents 4 0 R >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn root_pages_pointing_into_tree_is_corrected() {
let bytes = pdf_with_root_pages_pointing_into_tree();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else the repair pass is \
skipped behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let catalog = pdf.resolve(ObjectRef::new(1, 0)).expect("catalog resolves");
let Object::Dictionary(catalog_dict) = catalog else {
panic!("catalog is not a dictionary"); };
assert_eq!(
catalog_dict.get("Pages"),
Some(&Object::Reference(ObjectRef::new(2, 0))),
"the catalog's /Pages must be corrected from the leaf (3 0 R) to the \
true root /Pages node (2 0 R)"
);
}
fn pdf_with_root_pages_two_hop_chain() -> 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 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 /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] \
/Contents 5 0 R >>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n<< >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off5:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn root_pages_two_hop_chain_corrected_to_true_root() {
let bytes = pdf_with_root_pages_two_hop_chain();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else repair (6) is skipped \
behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let catalog = pdf.resolve(ObjectRef::new(1, 0)).expect("catalog resolves");
let Object::Dictionary(catalog_dict) = catalog else {
panic!("catalog is not a dictionary"); };
assert_eq!(
catalog_dict.get("Pages"),
Some(&Object::Reference(ObjectRef::new(2, 0))),
"the catalog's /Pages must be corrected two hops up to the true root \
(2 0 R), not left at the mid node (3 0 R)"
);
}
#[test]
fn correct_root_pages_is_unchanged() {
let bytes = pdf_with_no_inheritable_keys();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let catalog = pdf.resolve(ObjectRef::new(1, 0)).expect("catalog resolves");
let Object::Dictionary(catalog_dict) = catalog else {
panic!("catalog is not a dictionary"); };
assert_eq!(
catalog_dict.get("Pages"),
Some(&Object::Reference(ObjectRef::new(2, 0))),
"a catalog /Pages already at the true root must be left unchanged"
);
}
fn pdf_with_root_pages_parent_cycle() -> 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 /Parent 3 0 R /Kids [4 0 R] /Count 1 >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Pages /Parent 2 0 R >>\nendobj\n");
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(b"xref\n0 5\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off4:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn root_pages_parent_cycle_terminates() {
let bytes = pdf_with_root_pages_parent_cycle();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else repair (6) is skipped \
behind the !reconstructed gate (masking the loop guard): {:?}",
pdf.repair_diagnostics().entries(), );
let result = push_inherited_attributes_to_pages(&mut pdf);
assert!(
result.is_ok(),
"a /Parent cycle above the page tree root must terminate, not error: {result:?}"
);
let catalog = pdf.resolve(ObjectRef::new(1, 0)).expect("catalog resolves");
let Object::Dictionary(catalog_dict) = catalog else {
panic!("catalog is not a dictionary"); };
assert_eq!(
catalog_dict.get("Pages"),
Some(&Object::Reference(ObjectRef::new(2, 0))),
"a /Parent cycle must leave /Pages at the node where the guard broke (2 0 R)"
);
}
fn pdf_with_root_pages_non_reference_parent() -> 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 /Parent << >> /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;
pdf.extend_from_slice(b"xref\n0 4\n0000000000 65535 f \n");
pdf.extend_from_slice(format!("{off1:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off2:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(format!("{off3:010} 00000 n \n").as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn root_pages_non_reference_parent_stops_correction() {
let bytes = pdf_with_root_pages_non_reference_parent();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("valid PDF");
assert!(
pdf.repair_diagnostics().entries().is_empty(),
"fixture must NOT trip xref reconstruction, else repair (6) is skipped \
behind the !reconstructed gate: {:?}",
pdf.repair_diagnostics().entries(), );
push_inherited_attributes_to_pages(&mut pdf).expect("push must succeed");
let catalog = pdf.resolve(ObjectRef::new(1, 0)).expect("catalog resolves");
let Object::Dictionary(catalog_dict) = catalog else {
panic!("catalog is not a dictionary"); };
assert_eq!(
catalog_dict.get("Pages"),
Some(&Object::Reference(ObjectRef::new(2, 0))),
"a non-reference /Parent must stop the walk, leaving /Pages unchanged"
);
}
}