use crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH;
use crate::ObjectHandle;
use crate::{Error, ObjectRef, Pdf, Result};
use std::collections::HashSet;
use std::io::{Read, Seek};
pub fn splice_pages<R: Read + Seek>(
pdf: &mut Pdf<R>,
remove: std::ops::Range<usize>,
insert: &[ObjectRef],
) -> Result<()> {
splice_pages_with_max_depth(pdf, remove, insert, DEFAULT_MAX_PAGE_TREE_DEPTH)
}
pub fn splice_pages_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
remove: std::ops::Range<usize>,
insert: &[ObjectRef],
max_depth: usize,
) -> Result<()> {
if remove.start > remove.end {
return Err(Error::Unsupported(format!(
"splice: invalid range {}..{} (start > end)",
remove.start, remove.end
)));
}
if remove.is_empty() && insert.is_empty() {
return Ok(());
}
let pages_ref = pages_ref(pdf)?;
pdf.invalidate_page_list_cache();
let existing_pages = page_refs_for_splice(pdf, pages_ref, max_depth)?;
let page_count = existing_pages.len();
if remove.end > page_count {
return Err(Error::Unsupported(format!(
"splice: remove.end {} exceeds page count {}",
remove.end, page_count
)));
}
let normalized_insert = normalize_insert_pages(pdf, &existing_pages, &remove, insert)?;
let remaining = page_count - remove.len() + normalized_insert.len();
if remaining == 0 {
return Err(Error::Missing("splice would result in an empty document"));
}
let mut insert_done = false;
let pages_node = pdf.get_object_handle(pages_ref);
splice_subtree(
pdf,
pages_node,
0,
&remove,
&normalized_insert,
&mut insert_done,
0,
max_depth,
)?;
if !insert_done && !normalized_insert.is_empty() {
return Err(Error::Unsupported(format!(
"splice: insert position {} not found in page tree",
remove.start
)));
}
Ok(())
}
fn pages_ref<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<ObjectRef> {
let catalog_ref = pdf.root_ref().ok_or(Error::Missing("/Root"))?;
let catalog = pdf.get_object_handle(catalog_ref);
if !catalog.try_is_dictionary()? {
return Err(Error::Missing("/Catalog dict"));
}
let pages = catalog.try_get_key(b"/Pages")?;
if let Some(pages_ref) = pages.object_ref() {
return Ok(pages_ref);
}
if !pages.try_is_dictionary()? {
return Err(Error::Missing("/Pages"));
}
let indirect = pdf.make_indirect_object_handle(pages)?;
let pages_ref = indirect
.object_ref()
.ok_or_else(|| Error::Internal("direct /Pages promotion lost its identity".to_owned()))?;
catalog.replace_key(b"/Pages", indirect)?;
Ok(pages_ref)
}
fn node_label(node: &ObjectHandle) -> String {
node.object_ref()
.map(|object_ref| object_ref.to_string())
.unwrap_or_else(|| "direct object".to_owned())
}
#[allow(
clippy::mutable_key_type,
reason = "qpdf page-tree cycle detection intentionally keys on canonical ObjectHandle identity"
)]
fn page_refs_for_splice<R: Read + Seek>(
pdf: &mut Pdf<R>,
pages_ref: ObjectRef,
max_depth: usize,
) -> Result<Vec<ObjectRef>> {
pdf.mark_get_all_pages_called();
let mut pages = Vec::new();
let mut seen = HashSet::new();
let mut visited = HashSet::new();
let root = pdf.get_object_handle(pages_ref);
collect_page_refs(
pdf,
root,
0,
max_depth,
true,
&mut pages,
&mut seen,
&mut visited,
)?;
Ok(pages)
}
#[allow(
clippy::mutable_key_type,
clippy::too_many_arguments,
reason = "qpdf page-tree cycle detection intentionally keys on canonical ObjectHandle identity"
)]
fn collect_page_refs<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: ObjectHandle,
depth: usize,
max_depth: usize,
is_root: bool,
pages: &mut Vec<ObjectRef>,
seen: &mut HashSet<ObjectRef>,
visited: &mut HashSet<crate::object_handle::ObjectHandleIdentity>,
) -> Result<usize> {
let node_label = node_label(&node);
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"page-tree depth exceeds {max_depth} at {node_label}"
)));
}
if !node.try_is_dictionary()? {
return Err(Error::Unsupported(format!(
"node {node_label} is not a dictionary"
)));
}
let node_type = node.try_get_key(b"/Type")?;
let has_kids = is_root || node.try_has_key(b"/Kids")?;
if !has_kids {
if node_type.try_as_name()?.as_deref() != Some(b"Page") {
node.replace_key(b"/Type", ObjectHandle::name(b"Page".to_vec()))?;
}
let page_ref = node
.object_ref()
.ok_or_else(|| Error::Internal("page-tree leaf has no indirect identity".to_owned()))?;
pages.push(page_ref);
return Ok(1);
}
if node_type.try_as_name()?.as_deref() != Some(b"Pages") {
node.replace_key(b"/Type", ObjectHandle::name(b"Pages".to_vec()))?;
}
if !visited.insert(node.identity_key()) {
return Err(crate::pages::repair::page_tree_cycle_error(pdf));
}
let kids_value = node.try_get_key(b"/Kids")?;
let kids = kids_value.try_as_array()?;
let kids_handle = kids.as_ref().map(|_| kids_value.clone());
let mut actual_count = 0usize;
for (index, mut child) in kids.unwrap_or_default().into_iter().enumerate() {
let child_is_pages = child.try_is_dictionary()? && child.try_has_key(b"/Kids")?;
if !child_is_pages && child.is_direct() {
let indirect = pdf.make_indirect_object_handle(child)?;
let kids_handle = kids_handle
.as_ref()
.expect("array handle exists when promoting a direct child");
kids_handle.set_array_item(index, indirect.clone())?;
child = indirect;
}
if !child_is_pages {
let child_ref = child.object_ref().ok_or_else(|| {
Error::Internal("page-tree leaf has no indirect identity".to_owned())
})?;
if !seen.insert(child_ref) {
let copy = child.shallow_copy()?;
let indirect = pdf.make_indirect_object_handle(copy)?;
let kids_handle = kids_handle
.as_ref()
.expect("array handle exists when copying a duplicate page");
kids_handle.set_array_item(index, indirect.clone())?;
child = indirect;
}
}
let child_count = collect_page_refs(
pdf,
child,
depth + 1,
max_depth,
false,
pages,
seen,
visited,
)?;
actual_count = actual_count.checked_add(child_count).ok_or_else(|| {
Error::Unsupported(format!("page count overflow at /Pages node {node_label}"))
})?;
}
let count_value = node.try_get_key(b"/Count")?;
let declared_count = match count_value.try_as_integer()? {
Some(n) if n >= 0 => n as usize,
Some(n) => {
return Err(Error::Unsupported(format!(
"/Pages node {node_label} has negative /Count {n}"
)))
}
None => {
return Err(Error::Unsupported(format!(
"/Pages node {node_label} has no /Count"
)))
}
};
if declared_count != actual_count {
return Err(Error::Unsupported(format!(
"/Pages node {node_label} has /Count {declared_count}, but /Kids contain {actual_count} pages"
)));
}
Ok(actual_count)
}
fn normalize_insert_pages<R: Read + Seek>(
pdf: &mut Pdf<R>,
existing_pages: &[ObjectRef],
remove: &std::ops::Range<usize>,
insert: &[ObjectRef],
) -> Result<Vec<ObjectRef>> {
let mut occupied = HashSet::with_capacity(existing_pages.len() + insert.len());
for (index, &page_ref) in existing_pages.iter().enumerate() {
if !remove.contains(&index) {
occupied.insert(page_ref);
}
}
let mut normalized = Vec::with_capacity(insert.len());
for &page_ref in insert {
if occupied.insert(page_ref) {
normalized.push(page_ref);
continue;
}
let page = pdf.get_object_handle(page_ref);
let copy = page.shallow_copy()?;
let indirect = pdf.make_indirect_object_handle(copy)?;
let copy_ref = indirect.object_ref().ok_or_else(|| {
Error::Internal("shallow page copy did not receive an indirect identity".to_owned())
})?;
occupied.insert(copy_ref);
normalized.push(copy_ref);
}
Ok(normalized)
}
fn leaf_count_of(node: &ObjectHandle) -> Result<usize> {
let node_label = node_label(node);
if !node.try_is_dictionary()? {
return Err(Error::Unsupported(format!(
"node {node_label} is not a dictionary"
)));
}
if !node.try_has_key(b"/Kids")? {
return Ok(1);
}
let count = node.try_get_key(b"/Count")?;
match count.try_as_integer()? {
Some(n) if n >= 0 => Ok(n as usize),
Some(n) => Err(Error::Unsupported(format!(
"/Pages node {node_label} has negative /Count {n}"
))),
None => Err(Error::Unsupported(format!(
"/Pages node {node_label} has no /Count"
))),
}
}
fn set_page_parent_for_node<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
parent: &ObjectHandle,
) -> Result<()> {
let page = pdf.get_object_handle(page_ref);
if !page.try_is_dictionary()? {
return Err(Error::Unsupported(format!(
"page {page_ref} is not a dictionary"
)));
}
if let Some(parent_ref) = parent.object_ref() {
page.replace_key(b"/Parent", pdf.get_object_handle(parent_ref))?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn splice_subtree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: ObjectHandle,
base: usize,
remove: &std::ops::Range<usize>,
insert: &[ObjectRef],
insert_done: &mut bool,
depth: usize,
max_depth: usize,
) -> Result<i64> {
let node_label = node_label(&node);
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"page-tree depth exceeds {max_depth} at {node_label}"
)));
}
let (kids, old_count, kids_handle) = {
if !node.try_is_dictionary()? {
return Err(Error::Unsupported(format!(
"{node_label} is not a /Pages dictionary"
)));
}
let kids_value = node.try_get_key(b"/Kids")?;
let kids = kids_value.try_as_array()?;
let kids_handle = kids.as_ref().map(|_| kids_value.clone());
let kids = kids.unwrap_or_default();
for child in &kids {
let child_is_pages = child.try_is_dictionary()? && child.try_has_key(b"/Kids")?;
if child.is_direct() && !child_is_pages {
return Err(Error::Unsupported(format!(
"child of /Pages node {node_label} is not an indirect object"
)));
}
}
let count_value = node.try_get_key(b"/Count")?;
let old_count_raw = count_value
.try_as_integer()?
.ok_or_else(|| Error::Unsupported(format!("/Pages node {node_label} has no /Count")))?;
if old_count_raw < 0 {
return Err(Error::Unsupported(format!(
"/Pages node {node_label} has negative /Count {old_count_raw}"
)));
}
let old_count = old_count_raw as usize;
(kids, old_count, kids_handle)
};
let actual_count = kids.iter().try_fold(0usize, |total, child| {
let child_count = leaf_count_of(child)?;
total.checked_add(child_count).ok_or_else(|| {
Error::Unsupported(format!("page count overflow at /Pages node {node_label}"))
})
})?;
if old_count != actual_count {
return Err(Error::Unsupported(format!(
"/Pages node {node_label} has /Count {old_count}, but /Kids contain {actual_count} pages"
)));
}
let mut new_kids: Vec<ObjectHandle> = Vec::with_capacity(kids.len() + insert.len());
let mut net_delta: i64 = 0;
let mut offset = base;
for kid in kids {
let kid_leaf_count = leaf_count_of(&kid)?;
let kid_start = offset;
let kid_end = offset + kid_leaf_count;
if !*insert_done && remove.start == kid_start {
for &page_ref in insert {
new_kids.push(pdf.get_object_handle(page_ref));
set_page_parent_for_node(pdf, page_ref, &node)?;
}
net_delta += insert.len() as i64;
*insert_done = true;
}
let overlaps_remove = kid_end > remove.start && kid_start < remove.end;
if overlaps_remove {
let kid_is_pages = kid.try_is_dictionary()? && kid.try_has_key(b"/Kids")?;
if kid_is_pages {
let sub_delta = splice_subtree(
pdf,
kid.clone(),
kid_start,
remove,
insert,
insert_done,
depth + 1,
max_depth,
)?;
net_delta += sub_delta;
let new_sub_count = kid_leaf_count as i64 + sub_delta;
if new_sub_count > 0 {
new_kids.push(kid);
}
} else {
net_delta -= 1;
}
} else {
new_kids.push(kid);
}
offset = kid_end;
}
if !*insert_done && remove.start == offset {
for &page_ref in insert {
new_kids.push(pdf.get_object_handle(page_ref));
set_page_parent_for_node(pdf, page_ref, &node)?;
}
net_delta += insert.len() as i64;
*insert_done = true;
}
let new_count = old_count as i64 + net_delta;
if new_count < 0 {
return Err(Error::Unsupported(format!(
"splice: negative page count {new_count} for node {node_label}",
)));
}
node.replace_key(b"/Count", ObjectHandle::integer(new_count))?;
if let Some(kids_handle) = kids_handle {
kids_handle.set_array_items(new_kids)?;
} else {
node.replace_key(b"/Kids", ObjectHandle::array(new_kids))?;
}
Ok(net_delta)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::pages::page_refs;
use crate::Pdf;
use std::collections::BTreeMap;
use std::io::Cursor;
fn build_flat_pdf() -> Vec<u8> {
let parts: &[(u32, &str)] = &[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 4 0 R 5 0 R] /Count 3 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
];
build_pdf(parts)
}
fn build_nested_pdf() -> Vec<u8> {
let parts: &[(u32, &str)] = &[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 6 0 R] /Count 4 >>"),
(
3,
"<< /Type /Pages /Parent 2 0 R /Kids [4 0 R 5 0 R] /Count 2 >>",
),
(4, "<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>"),
(
6,
"<< /Type /Pages /Parent 2 0 R /Kids [7 0 R 8 0 R] /Count 2 >>",
),
(7, "<< /Type /Page /Parent 6 0 R /MediaBox [0 0 612 792] >>"),
(8, "<< /Type /Page /Parent 6 0 R /MediaBox [0 0 612 792] >>"),
];
build_pdf(parts)
}
fn build_indirect_flat_pdf() -> Vec<u8> {
let parts: &[(u32, &str)] = &[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids 9 0 R /Count 10 0 R >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(9, "[3 0 R 4 0 R 5 0 R]"),
(10, "3"),
];
build_pdf(parts)
}
fn build_catalog_not_dictionary_pdf() -> Vec<u8> {
build_pdf(&[(1, "[]")])
}
fn build_catalog_with_direct_pages_not_dictionary_pdf() -> Vec<u8> {
build_pdf(&[(1, "<< /Type /Catalog /Pages [] >>")])
}
fn build_pages_not_dictionary_pdf() -> Vec<u8> {
build_pdf(&[(1, "<< /Type /Catalog /Pages 2 0 R >>"), (2, "[]")])
}
fn build_pages_with_count_pdf(count: &str) -> Vec<u8> {
build_pdf(&[(1, "<< /Type /Catalog /Pages 2 0 R >>"), (2, count)])
}
fn build_pages_with_mismatched_count_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 2 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_direct_kid_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [<< /Type /Page /MediaBox [0 0 612 792] >>] /Count 1 >>",
),
(3, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_direct_intermediate_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [<< /Type /Pages /Kids [3 0 R] /Count 1 >>] /Count 1 >>",
),
(3, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_two_direct_intermediates_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [<< /Type /Pages /Kids [3 0 R] /Count 1 >> << /Type /Pages /Kids [4 0 R] /Count 1 >>] /Count 2 >>",
),
(3, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_direct_intermediate_two_pages_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>] /Count 2 >>",
),
(3, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_duplicate_kid_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 3 0 R 4 0 R] /Count 3 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_cross_parent_duplicate_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 6 0 R] /Count 2 >>"),
(3, "<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 >>"),
(4, "<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>"),
(6, "<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 >>"),
(8, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_shared_intermediate_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 3 0 R] /Count 2 >>"),
(3, "<< /Type /Pages /Parent 2 0 R /Kids [4 0 R] /Count 1 >>"),
(4, "<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pages_with_direct_kid_before_invalid_kid_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(
2,
"<< /Type /Pages /Kids [<< /Type /Page /MediaBox [0 0 612 792] >> 3 0 R] /Count 2 >>",
),
(3, "[]"),
])
}
fn build_pages_with_malformed_types_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /NotPages /Kids [3 0 R] /Count 1 >>"),
(
3,
"<< /Type /NotPages /Parent 2 0 R /Kids [4 0 R] /Count 1 >>",
),
(
4,
"<< /Type /NotPage /Parent 3 0 R /MediaBox [0 0 612 792] >>",
),
(5, "<< /Type /NotPage /MediaBox [0 0 612 792] >>"),
])
}
fn build_direct_pages_root_pdf() -> Vec<u8> {
build_pdf(&[
(
1,
"<< /Type /Catalog /Pages << /Type /Pages /Kids [3 0 R] /Count 1 >> >>",
),
(3, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
(4, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_empty_pages_without_kids_pdf() -> Vec<u8> {
build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Count 0 >>"),
(3, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
])
}
fn build_pdf(parts: &[(u32, &str)]) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.5\n".to_vec();
let mut offs: BTreeMap<u32, u64> = BTreeMap::new();
for (n, s) in parts {
offs.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{s}\nendobj\n").as_bytes());
}
let max_obj = parts.iter().map(|(n, _)| n).max().copied().unwrap_or(0);
let total = max_obj + 1;
let xref_start = out.len() as u64;
out.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for i in 1..total {
out.extend_from_slice(
format!("{:010} 00000 n \n", offs.get(&i).copied().unwrap_or(0)).as_bytes(),
);
}
out.extend_from_slice(
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
out
}
fn open(bytes: Vec<u8>) -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(bytes)).expect("PDF should parse")
}
fn page_list(pdf: &mut Pdf<Cursor<Vec<u8>>>) -> Vec<ObjectRef> {
page_refs(pdf).expect("page_refs failed")
}
fn dict_handle_of(pdf: &mut Pdf<Cursor<Vec<u8>>>, r: ObjectRef) -> ObjectHandle {
let handle = pdf.get_object_handle(r);
handle.try_is_scalar().expect("object should resolve");
assert!(handle.as_dictionary().is_some(), "not a dictionary");
handle
}
fn new_page_handle() -> ObjectHandle {
ObjectHandle::dictionary(vec![
(b"/Type".to_vec(), ObjectHandle::name(b"Page".to_vec())),
(
b"/MediaBox".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::integer(0),
ObjectHandle::integer(0),
ObjectHandle::integer(612),
ObjectHandle::integer(792),
]),
),
])
}
#[test]
fn noop_returns_ok_and_does_not_mutate() {
let mut pdf = open(build_flat_pdf());
let before = page_list(&mut pdf);
splice_pages(&mut pdf, 0..0, &[]).unwrap();
let after = page_list(&mut pdf);
assert_eq!(before, after);
}
#[test]
fn splice_marks_get_all_pages_called_like_qpdfs_getallpages() {
let mut pdf = open(build_flat_pdf());
assert!(!pdf.ever_called_get_all_pages());
splice_pages(&mut pdf, 0..1, &[]).unwrap();
assert!(pdf.ever_called_get_all_pages());
}
#[test]
fn splice_invalidates_a_prepared_page_cache_before_mutating_the_tree() {
let mut pdf = open(build_flat_pdf());
let prepared = crate::pages::repair::prepare_for_optimization(&mut pdf)
.unwrap()
.expect("flat page tree should be prepared");
assert_eq!(
prepared
.pages
.iter()
.map(|page| page.object_ref().expect("page identity"))
.collect::<Vec<_>>(),
page_list(&mut pdf)
);
splice_pages(&mut pdf, 0..1, &[]).unwrap();
assert_eq!(
page_list(&mut pdf),
vec![ObjectRef::new(4, 0), ObjectRef::new(5, 0)]
);
}
#[test]
fn remove_first_page_flat_tree() {
let mut pdf = open(build_flat_pdf());
splice_pages(&mut pdf, 0..1, &[]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 2);
assert_eq!(pages[0], ObjectRef::new(4, 0)); assert_eq!(pages[1], ObjectRef::new(5, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(2));
}
#[test]
fn remove_last_page_flat_tree() {
let mut pdf = open(build_flat_pdf());
splice_pages(&mut pdf, 2..3, &[]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 2);
assert_eq!(pages[0], ObjectRef::new(3, 0)); assert_eq!(pages[1], ObjectRef::new(4, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(2));
}
#[test]
fn insert_at_start_flat_tree() {
let mut pdf = open(build_flat_pdf());
let new_page = ObjectRef::new(6, 0);
pdf.replace_object(new_page, new_page_handle()).unwrap();
splice_pages(&mut pdf, 0..0, &[new_page]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 4);
assert_eq!(pages[0], new_page);
assert_eq!(pages[1], ObjectRef::new(3, 0));
let d = dict_handle_of(&mut pdf, new_page);
assert_eq!(
d.try_get_key(b"/Parent").unwrap().object_ref(),
Some(ObjectRef::new(2, 0))
);
let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(4));
}
#[test]
fn insert_at_end_flat_tree() {
let mut pdf = open(build_flat_pdf());
let new_page = ObjectRef::new(6, 0);
pdf.replace_object(new_page, new_page_handle()).unwrap();
splice_pages(&mut pdf, 3..3, &[new_page]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 4);
assert_eq!(pages[3], new_page);
let d = dict_handle_of(&mut pdf, new_page);
assert_eq!(
d.try_get_key(b"/Parent").unwrap().object_ref(),
Some(ObjectRef::new(2, 0))
);
}
#[test]
fn insert_in_middle_flat_tree() {
let mut pdf = open(build_flat_pdf());
let new_page = ObjectRef::new(6, 0);
pdf.replace_object(new_page, new_page_handle()).unwrap();
splice_pages(&mut pdf, 2..2, &[new_page]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 4);
assert_eq!(pages[0], ObjectRef::new(3, 0)); assert_eq!(pages[1], ObjectRef::new(4, 0)); assert_eq!(pages[2], new_page); assert_eq!(pages[3], ObjectRef::new(5, 0)); }
#[test]
fn remove_range_flat_tree() {
let mut pdf = open(build_flat_pdf());
splice_pages(&mut pdf, 0..2, &[]).unwrap(); let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 1);
assert_eq!(pages[0], ObjectRef::new(5, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(1));
}
#[test]
fn indirect_kids_and_count_are_mutated_canonically() {
let mut pdf = open(build_indirect_flat_pdf());
splice_pages(&mut pdf, 1..2, &[]).unwrap();
let root = pdf.get_object_handle(ObjectRef::new(2, 0));
root.try_is_scalar().unwrap();
let kids_ref = root.try_get_key(b"/Kids").unwrap().object_ref();
assert_eq!(kids_ref, Some(ObjectRef::new(9, 0)));
let kids = pdf.get_object_handle(ObjectRef::new(9, 0));
kids.try_is_scalar().unwrap();
let kids = kids
.as_array()
.expect("indirect /Kids array remains canonical");
let kids_refs: Vec<_> = kids
.iter()
.map(|child| child.object_ref().expect("/Kids entry reference"))
.collect();
assert_eq!(kids_refs, vec![ObjectRef::new(3, 0), ObjectRef::new(5, 0)]);
let count = root.try_get_key(b"/Count").unwrap();
count.try_is_scalar().unwrap();
assert_eq!(count.as_integer(), Some(2));
}
#[test]
fn count_mismatch_between_pages_kids_is_rejected() {
let mut pdf = open(build_pages_with_mismatched_count_pdf());
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(
matches!(err, Error::Unsupported(ref message) if message.contains("/Count 2") && message.contains("1")),
"got {err:?}"
);
}
#[test]
fn direct_page_kid_is_promoted_by_the_public_walk() {
let mut pdf = open(build_pages_with_direct_kid_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(3, 0)]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 2);
assert_eq!(pages[0], ObjectRef::new(3, 0));
assert_ne!(pages[1], ObjectRef::new(3, 0));
let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
let kids = root.try_get_key(b"/Kids").unwrap().as_array().unwrap();
assert!(kids.iter().all(|kid| kid.object_ref().is_some()));
}
#[test]
fn direct_intermediate_page_kid_stays_inline_during_splice() {
let mut pdf = open(build_pages_with_direct_intermediate_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(4, 0)]).unwrap();
let root = pdf.get_object_handle(ObjectRef::new(2, 0));
root.try_is_scalar().unwrap();
let kids = root.try_get_key(b"/Kids").unwrap();
kids.try_is_scalar().unwrap();
let kids = kids.as_array().expect("root /Kids array");
assert_eq!(kids.len(), 2);
assert_eq!(kids[0].object_ref(), Some(ObjectRef::new(4, 0)));
assert!(kids[1].is_direct(), "intermediate /Pages must stay inline");
assert!(kids[1].try_has_key(b"/Kids").unwrap());
}
#[test]
fn distinct_direct_intermediate_siblings_do_not_collide_in_cycle_guard() {
let mut pdf = open(build_pages_with_two_direct_intermediates_pdf());
splice_pages(&mut pdf, 1..1, &[ObjectRef::new(5, 0)]).unwrap();
let root = pdf.get_object_handle(ObjectRef::new(2, 0));
root.try_is_scalar().unwrap();
let kids = root.try_get_key(b"/Kids").unwrap();
kids.try_is_scalar().unwrap();
let kids = kids.as_array().expect("root /Kids array");
assert_eq!(kids.len(), 3);
assert!(kids[0].is_direct());
assert_eq!(kids[1].object_ref(), Some(ObjectRef::new(5, 0)));
assert!(kids[2].is_direct());
}
#[test]
fn direct_intermediate_page_kid_is_mutated_in_place() {
let mut pdf = open(build_pages_with_direct_intermediate_two_pages_pdf());
splice_pages(&mut pdf, 0..1, &[]).unwrap();
let root = pdf.get_object_handle(ObjectRef::new(2, 0));
root.try_is_scalar().unwrap();
let kids = root.try_get_key(b"/Kids").unwrap();
kids.try_is_scalar().unwrap();
let root_kids = kids.as_array().expect("root /Kids array");
assert_eq!(
root_kids.len(),
1,
"root should retain one direct intermediate /Pages node"
);
let intermediate = &root_kids[0];
assert!(intermediate.is_direct());
let count = intermediate.try_get_key(b"/Count").unwrap();
count.try_is_scalar().unwrap();
assert_eq!(count.as_integer(), Some(1));
let child_kids = intermediate.try_get_key(b"/Kids").unwrap();
child_kids.try_is_scalar().unwrap();
let child_kids = child_kids.as_array().expect("intermediate /Kids array");
assert_eq!(child_kids.len(), 1);
assert_eq!(child_kids[0].object_ref(), Some(ObjectRef::new(4, 0)));
}
#[test]
fn insertion_into_direct_intermediate_does_not_fabricate_parent_ref() {
let mut pdf = open(build_pages_with_direct_intermediate_two_pages_pdf());
splice_pages(&mut pdf, 1..1, &[ObjectRef::new(5, 0)]).unwrap();
let root = pdf.get_object_handle(ObjectRef::new(2, 0));
root.try_is_scalar().unwrap();
let root_kids = root.try_get_key(b"/Kids").unwrap();
root_kids.try_is_scalar().unwrap();
let root_kids = root_kids.as_array().expect("root /Kids array");
assert_eq!(root_kids.len(), 1);
let intermediate = &root_kids[0];
assert!(intermediate.is_direct());
let child_kids = intermediate.try_get_key(b"/Kids").unwrap();
child_kids.try_is_scalar().unwrap();
let child_kids = child_kids.as_array().expect("intermediate /Kids array");
let child_refs: Vec<_> = child_kids
.iter()
.map(|child| child.object_ref().expect("page child reference"))
.collect();
assert_eq!(
child_refs,
vec![
ObjectRef::new(3, 0),
ObjectRef::new(5, 0),
ObjectRef::new(4, 0)
]
);
let inserted = dict_handle_of(&mut pdf, ObjectRef::new(5, 0));
assert!(
!inserted
.as_dictionary()
.expect("resolved dictionary")
.contains_key(b"/Parent".as_slice()),
"/Parent must be genuinely absent, not present as an explicit null \
(has_key alone can't distinguish the two)"
);
}
#[test]
fn duplicate_page_kid_is_shallow_copied_during_preflight() {
let mut pdf = open(build_pages_with_duplicate_kid_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(5, 0)]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 4);
assert_eq!(pages[0], ObjectRef::new(5, 0));
assert_eq!(pages[1], ObjectRef::new(3, 0));
assert_ne!(pages[2], ObjectRef::new(3, 0));
assert_eq!(pages[3], ObjectRef::new(4, 0));
}
#[test]
fn duplicate_page_kid_copy_keeps_the_stale_parent_of_its_original() {
let mut pdf = open(build_pages_with_cross_parent_duplicate_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(8, 0)]).unwrap();
let right = dict_handle_of(&mut pdf, ObjectRef::new(6, 0));
let kids = right.try_get_key(b"/Kids").unwrap().as_array().unwrap();
assert_eq!(
kids.len(),
1,
"right /Kids should contain one indirect page"
);
let duplicate = &kids[0];
let duplicate = duplicate
.object_ref()
.expect("right /Kids entry should be indirect");
assert_ne!(duplicate, ObjectRef::new(4, 0));
assert_eq!(
dict_handle_of(&mut pdf, duplicate)
.try_get_key(b"/Parent")
.unwrap()
.object_ref(),
Some(ObjectRef::new(3, 0))
);
}
#[test]
fn shared_intermediate_page_tree_is_rejected_as_a_loop() {
let mut pdf = open(build_pages_with_shared_intermediate_pdf());
let err = splice_pages(&mut pdf, 0..0, &[ObjectRef::new(5, 0)]).unwrap_err();
let is_qpdf_pages_exception = matches!(
&err,
Error::QpdfExc(exception)
if exception.get_error_code() == crate::QpdfErrorCode::Pages
&& exception.get_message_detail()
== b"Loop detected in /Pages structure (getAllPages)"
&& exception.get_object() == b"object 4 0"
);
assert!(is_qpdf_pages_exception, "got {err:?}");
}
#[test]
fn shared_empty_intermediate_names_the_repeated_node_like_qpdf() {
let mut pdf = open(build_pdf(&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 3 0 R 6 0 R] /Count 2 >>"),
(3, "<< /Type /Pages /Parent 2 0 R /Kids [] /Count 0 >>"),
(6, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(5, "<< /Type /Page /MediaBox [0 0 612 792] >>"),
]));
let err = splice_pages(&mut pdf, 0..0, &[ObjectRef::new(5, 0)]).unwrap_err();
let is_qpdf_pages_exception = matches!(
&err,
Error::QpdfExc(exception)
if exception.get_error_code() == crate::QpdfErrorCode::Pages
&& exception.get_message_detail()
== b"Loop detected in /Pages structure (getAllPages)"
&& exception.get_object() == b"object 3 0"
);
assert!(is_qpdf_pages_exception, "got {err:?}");
}
#[test]
fn direct_kid_promotion_remains_visible_after_later_preflight_error() {
let mut pdf = open(build_pages_with_direct_kid_before_invalid_kid_pdf());
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
let output = crate::writer::write_qpdf_to_memory(&mut pdf, |_| {}).unwrap();
let mut round_trip = open(output);
let root = dict_handle_of(&mut round_trip, ObjectRef::new(2, 0));
let kids = root.try_get_key(b"/Kids").unwrap().as_array().unwrap();
assert!(kids.first().is_some_and(|kid| kid.object_ref().is_some()));
}
#[test]
fn malformed_page_tree_types_are_normalized_by_the_public_walk() {
let mut pdf = open(build_pages_with_malformed_types_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(5, 0)]).unwrap();
assert_eq!(
dict_handle_of(&mut pdf, ObjectRef::new(2, 0))
.try_get_key(b"/Type")
.unwrap()
.as_name(),
Some(b"Pages".to_vec())
);
assert_eq!(
dict_handle_of(&mut pdf, ObjectRef::new(3, 0))
.try_get_key(b"/Type")
.unwrap()
.as_name(),
Some(b"Pages".to_vec())
);
assert_eq!(
dict_handle_of(&mut pdf, ObjectRef::new(4, 0))
.try_get_key(b"/Type")
.unwrap()
.as_name(),
Some(b"Page".to_vec())
);
}
#[test]
fn direct_pages_root_is_promoted_before_splice() {
let mut pdf = open(build_direct_pages_root_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(4, 0)]).unwrap();
let catalog = pdf.get_object_handle(ObjectRef::new(1, 0));
catalog.try_is_scalar().unwrap();
let pages = catalog.try_get_key(b"/Pages").unwrap();
assert!(pages.object_ref().is_some());
assert_eq!(page_list(&mut pdf).len(), 2);
}
#[test]
fn missing_kids_is_replaced_when_inserting_into_an_empty_tree() {
let mut pdf = open(build_empty_pages_without_kids_pdf());
splice_pages(&mut pdf, 0..0, &[ObjectRef::new(3, 0)]).unwrap();
assert_eq!(page_list(&mut pdf), vec![ObjectRef::new(3, 0)]);
let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(1));
assert_eq!(
root.try_get_key(b"/Kids")
.unwrap()
.as_array()
.map(|items| items.len()),
Some(1)
);
}
#[test]
fn inserting_an_existing_page_shallow_copies_it() {
let mut pdf = open(build_flat_pdf());
let original = ObjectRef::new(3, 0);
splice_pages(&mut pdf, 0..0, &[original]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 4);
assert_ne!(pages[0], original);
assert_eq!(pages[1], original);
let copy = dict_handle_of(&mut pdf, pages[0]);
assert_eq!(
copy.try_get_key(b"/Parent").unwrap().object_ref(),
Some(ObjectRef::new(2, 0))
);
}
#[test]
fn malformed_catalog_is_rejected_before_page_count() {
let mut pdf = open(build_catalog_not_dictionary_pdf());
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(
matches!(err, Error::Missing("/Catalog dict")),
"got {err:?}"
);
}
#[test]
fn direct_pages_entry_that_is_not_a_dictionary_is_rejected() {
let mut pdf = open(build_catalog_with_direct_pages_not_dictionary_pdf());
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(matches!(err, Error::Missing("/Pages")), "got {err:?}");
}
#[test]
fn non_dictionary_pages_root_is_rejected() {
let mut pdf = open(build_pages_not_dictionary_pdf());
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn negative_pages_count_is_rejected() {
let mut pdf = open(build_pages_with_count_pdf(
"<< /Type /Pages /Kids [] /Count -1 >>",
));
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn missing_pages_count_is_rejected() {
let mut pdf = open(build_pages_with_count_pdf("<< /Type /Pages /Kids [] >>"));
let err = splice_pages(&mut pdf, 0..1, &[]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn splice_subtree_rejects_a_non_dictionary_node() {
let mut pdf = open(build_pages_not_dictionary_pdf());
let pages = pdf.get_object_handle(ObjectRef::new(2, 0));
let mut insert_done = false;
let err = splice_subtree(
&mut pdf,
pages,
0,
&(0..0),
&[],
&mut insert_done,
0,
DEFAULT_MAX_PAGE_TREE_DEPTH,
)
.unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn splice_subtree_rejects_a_count_mismatch() {
let mut pdf = open(build_pages_with_mismatched_count_pdf());
let pages = pdf.get_object_handle(ObjectRef::new(2, 0));
let mut insert_done = false;
let err = splice_subtree(
&mut pdf,
pages,
0,
&(0..1),
&[],
&mut insert_done,
0,
DEFAULT_MAX_PAGE_TREE_DEPTH,
)
.unwrap_err();
assert!(
matches!(err, Error::Unsupported(ref message) if message.contains("/Count 2") && message.contains("1")),
"got {err:?}"
);
}
#[test]
fn splice_subtree_rejects_a_direct_page_kid() {
let mut pdf = open(build_pages_with_direct_kid_pdf());
let pages = pdf.get_object_handle(ObjectRef::new(2, 0));
let mut insert_done = false;
let err = splice_subtree(
&mut pdf,
pages,
0,
&(0..1),
&[],
&mut insert_done,
0,
DEFAULT_MAX_PAGE_TREE_DEPTH,
)
.unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn splice_subtree_rejects_depth_limit_before_walking() {
let mut pdf = open(build_flat_pdf());
let pages = pdf.get_object_handle(ObjectRef::new(2, 0));
let mut insert_done = false;
let err =
splice_subtree(&mut pdf, pages, 0, &(0..0), &[], &mut insert_done, 0, 0).unwrap_err();
assert!(
matches!(err, Error::Unsupported(ref message) if message.contains("depth exceeds 0")),
"got {err:?}"
);
}
#[test]
fn splice_subtree_rejects_negative_count_before_leaf_walk() {
let mut pdf = open(build_pages_with_count_pdf(
"<< /Type /Pages /Kids [] /Count -1 >>",
));
let pages = pdf.get_object_handle(ObjectRef::new(2, 0));
let mut insert_done = false;
let err = splice_subtree(
&mut pdf,
pages,
0,
&(0..0),
&[],
&mut insert_done,
0,
DEFAULT_MAX_PAGE_TREE_DEPTH,
)
.unwrap_err();
assert!(
matches!(err, Error::Unsupported(ref message) if message.contains("negative /Count -1")),
"got {err:?}"
);
}
#[test]
fn leaf_count_of_rejects_a_non_dictionary_node() {
let mut pdf = open(build_pages_not_dictionary_pdf());
let pages = pdf.get_object_handle(ObjectRef::new(2, 0));
let err = leaf_count_of(&pages).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn leaf_count_of_rejects_negative_and_missing_counts() {
let mut negative = open(build_pages_with_count_pdf(
"<< /Type /Pages /Kids [] /Count -1 >>",
));
let negative_pages = negative.get_object_handle(ObjectRef::new(2, 0));
let negative_err = leaf_count_of(&negative_pages).unwrap_err();
assert!(matches!(negative_err, Error::Unsupported(_)));
let mut missing = open(build_pages_with_count_pdf("<< /Type /Pages /Kids [] >>"));
let missing_pages = missing.get_object_handle(ObjectRef::new(2, 0));
let missing_err = leaf_count_of(&missing_pages).unwrap_err();
assert!(matches!(missing_err, Error::Unsupported(_)));
}
#[test]
fn leaf_count_of_propagates_an_unresolved_child_resolution_error() {
let page = ObjectHandle::new_indirect_unresolved(ObjectRef::new(99, 0), -1);
let error = leaf_count_of(&page).unwrap_err();
assert!(
matches!(
error,
Error::Internal(ref message) if message == "object 99 0 belongs to a dropped PDF"
),
"got {error:?}"
);
}
#[test]
fn non_dictionary_insert_page_is_rejected() {
let mut pdf = open(build_flat_pdf());
let bad_page = ObjectRef::new(6, 0);
pdf.replace_object(bad_page, ObjectHandle::array(Vec::new()))
.unwrap();
let err = splice_pages(&mut pdf, 0..0, &[bad_page]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn non_dictionary_insert_page_into_direct_intermediate_is_rejected() {
let mut pdf = open(build_pages_with_direct_intermediate_two_pages_pdf());
let bad_page = ObjectRef::new(5, 0);
pdf.replace_object(bad_page, ObjectHandle::array(Vec::new()))
.unwrap();
let err = splice_pages(&mut pdf, 1..1, &[bad_page]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn replace_middle_page_flat_tree() {
let mut pdf = open(build_flat_pdf());
let new_page = ObjectRef::new(6, 0);
pdf.replace_object(new_page, new_page_handle()).unwrap();
splice_pages(&mut pdf, 1..2, &[new_page]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 3);
assert_eq!(pages[0], ObjectRef::new(3, 0)); assert_eq!(pages[1], new_page); assert_eq!(pages[2], ObjectRef::new(5, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(3));
}
#[test]
fn nested_remove_updates_intermediate_count() {
let mut pdf = open(build_nested_pdf());
splice_pages(&mut pdf, 1..2, &[]).unwrap(); let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 3);
assert_eq!(pages[0], ObjectRef::new(4, 0)); assert_eq!(pages[1], ObjectRef::new(7, 0)); assert_eq!(pages[2], ObjectRef::new(8, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(3));
let left = dict_handle_of(&mut pdf, ObjectRef::new(3, 0));
assert_eq!(left.try_get_key(b"/Count").unwrap().as_integer(), Some(1));
let right = dict_handle_of(&mut pdf, ObjectRef::new(6, 0));
assert_eq!(right.try_get_key(b"/Count").unwrap().as_integer(), Some(2));
}
#[test]
fn nested_remove_spanning_subtrees() {
let mut pdf = open(build_nested_pdf());
splice_pages(&mut pdf, 1..3, &[]).unwrap(); let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 2);
assert_eq!(pages[0], ObjectRef::new(4, 0)); assert_eq!(pages[1], ObjectRef::new(8, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(2));
let left = dict_handle_of(&mut pdf, ObjectRef::new(3, 0));
assert_eq!(left.try_get_key(b"/Count").unwrap().as_integer(), Some(1));
let right = dict_handle_of(&mut pdf, ObjectRef::new(6, 0));
assert_eq!(right.try_get_key(b"/Count").unwrap().as_integer(), Some(1));
}
#[test]
fn depth_limit_is_preserved_for_nested_page_trees() {
let mut pdf = open(build_nested_pdf());
let err = splice_pages_with_max_depth(&mut pdf, 0..1, &[], 1).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn error_remove_end_out_of_bounds() {
let mut pdf = open(build_flat_pdf()); let err = splice_pages(&mut pdf, 0..4, &[]).unwrap_err();
assert!(matches!(err, Error::Unsupported(_)), "got {err:?}");
}
#[test]
fn error_empty_result_document() {
let mut pdf = open(build_flat_pdf()); let err = splice_pages(&mut pdf, 0..3, &[]).unwrap_err();
assert!(matches!(err, Error::Missing(_)), "got {err:?}");
}
#[test]
fn empty_intermediate_node_is_dropped() {
let mut pdf = open(build_nested_pdf()); splice_pages(&mut pdf, 0..2, &[]).unwrap(); let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 2);
assert_eq!(pages[0], ObjectRef::new(7, 0)); assert_eq!(pages[1], ObjectRef::new(8, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
let kids = root.try_get_key(b"/Kids").unwrap().as_array().unwrap();
assert_eq!(kids.len(), 1);
assert_eq!(kids[0].object_ref(), Some(ObjectRef::new(6, 0)));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(2));
}
#[test]
fn nested_insert_at_subtree_boundary() {
let mut pdf = open(build_nested_pdf());
let new_page = ObjectRef::new(9, 0);
pdf.replace_object(new_page, new_page_handle()).unwrap();
splice_pages(&mut pdf, 2..2, &[new_page]).unwrap();
let pages = page_list(&mut pdf);
assert_eq!(pages.len(), 5);
assert_eq!(pages[0], ObjectRef::new(4, 0)); assert_eq!(pages[1], ObjectRef::new(5, 0)); assert_eq!(pages[2], new_page); assert_eq!(pages[3], ObjectRef::new(7, 0)); assert_eq!(pages[4], ObjectRef::new(8, 0)); let root = dict_handle_of(&mut pdf, ObjectRef::new(2, 0));
assert_eq!(root.try_get_key(b"/Count").unwrap().as_integer(), Some(5));
let d = dict_handle_of(&mut pdf, new_page);
let parent = d
.try_get_key(b"/Parent")
.unwrap()
.object_ref()
.expect("/Parent must be set");
let parent_dict = dict_handle_of(&mut pdf, parent);
assert_eq!(
parent_dict.try_get_key(b"/Type").unwrap().as_name(),
Some(b"Pages".to_vec())
);
}
}