use super::page_merge::{
merge_documents_with_resource_mode, merge_documents_with_resource_mode_and_preserve_primary,
source_top_level_field_names, MergeInput,
};
use super::page_plan::PagePlan;
use super::resource_pruning::RemoveUnreferencedResources;
use crate::form_field_object_helper::FormFieldObjectHelper;
use crate::page_label_document_helper::LabelRange;
use crate::pages::tree_rebuild::RebuildResult;
use crate::{
AcroFormDocumentHelper, Error, Matrix, ObjectHandle, ObjectRef, PageObjectHelper, PageRange,
Pdf, Result,
};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageSpecInput {
pub source_index: usize,
pub range: PageRange,
}
impl PageSpecInput {
#[must_use]
pub const fn new(source_index: usize, range: PageRange) -> Self {
Self {
source_index,
range,
}
}
}
fn merge_preserving_primary<R: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
resource_mode: RemoveUnreferencedResources,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
merge_documents_with_resource_mode_and_preserve_primary(inputs, resource_mode, true)
}
type OrderedPage = (usize, usize);
type JobLabelEntry = (i64, LabelRange, bool);
fn collect_primary_fields(
merged: &mut Pdf<Cursor<Vec<u8>>>,
pages: &[ObjectRef],
) -> Result<Vec<ObjectHandle>> {
let mut field_refs = BTreeSet::new();
let mut candidate_fields = Vec::new();
{
let mut acroform = AcroFormDocumentHelper::new_for_field_tree(merged)?;
for &page_ref in pages {
let widgets = acroform.get_widget_annotations_for_page(page_ref)?;
for widget in widgets {
let field = acroform.get_field_for_annotation_handle(widget)?;
if let Some(field_ref) = field.object_ref() {
candidate_fields.push(field_ref);
} }
}
}
for field_ref in candidate_fields {
let (top_level, _) = FormFieldObjectHelper::new(field_ref, merged).get_top_level_field()?;
field_refs.insert(top_level);
}
let primary_order = {
let mut acroform = AcroFormDocumentHelper::new_for_field_tree(merged)?;
acroform.top_level_fields()?
};
Ok(primary_order
.into_iter()
.filter(|field_ref| field_refs.contains(field_ref))
.map(|field_ref| merged.get_object_handle(field_ref))
.collect())
}
fn replace_merged_fields(
merged: &mut Pdf<Cursor<Vec<u8>>>,
fields: Vec<ObjectHandle>,
had_fields_array: bool,
) -> Result<()> {
if !had_fields_array {
return Ok(());
}
let Some(root_ref) = merged.root_ref() else {
return Ok(());
};
let root = merged.get_object_handle(root_ref);
let acroform = merged.resolve_handle(&root.try_get_key(b"/AcroForm")?)?;
let Some(_) = acroform.as_dictionary() else {
return Ok(());
};
if fields.is_empty() {
root.remove_key(b"/AcroForm");
merged.mark_object_handle_dirty(&root)?;
} else {
acroform.replace_key(b"/Fields", ObjectHandle::array(fields))?;
merged.mark_object_handle_dirty(&acroform)?;
}
Ok(())
}
fn set_annotation_page_refs(
merged: &mut Pdf<Cursor<Vec<u8>>>,
page_ref: ObjectRef,
first_output_page: ObjectRef,
) -> Result<()> {
let annotations = PageObjectHelper::new(page_ref, merged).get_annotation_handles(None)?;
let page = merged.get_object_handle(first_output_page);
for annotation in annotations {
if annotation.try_has_key(b"/P")? {
annotation.replace_key(b"/P", page.clone())?;
merged.mark_object_handle_dirty(&annotation)?;
}
}
Ok(())
}
fn rebuild_acroform_in_final_page_order<R: Read + Seek + 'static>(
merged: &mut Pdf<Cursor<Vec<u8>>>,
sources: &mut [Pdf<R>],
grouped_pages: &[Vec<usize>],
ordered_pages: &[OrderedPage],
final_refs: &[ObjectRef],
) -> Result<()> {
debug_assert_eq!(ordered_pages.len(), final_refs.len());
let primary_field_names: BTreeSet<Vec<u8>> = match sources.first_mut() {
Some(primary) => source_top_level_field_names(primary)?
.into_iter()
.filter_map(|(_, name)| name)
.collect(),
None => BTreeSet::new(),
};
let source_page_refs: Vec<Vec<ObjectRef>> = sources
.iter_mut()
.map(crate::pages::page_refs)
.collect::<Result<_>>()?;
let source_has_acroform: Vec<bool> = sources
.iter_mut()
.map(|source| source.acroform()?.has_acro_form())
.collect::<Result<_>>()?;
let mut first_output_for_source_page: Vec<BTreeMap<ObjectRef, ObjectRef>> =
vec![BTreeMap::new(); sources.len()];
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
first_output_for_source_page[source_index]
.entry(source_page_ref)
.or_insert(final_refs[output_index]);
}
let primary_first_pages: Vec<ObjectRef> = ordered_pages
.iter()
.enumerate()
.filter_map(|(output_index, &(source_index, group_index))| {
if source_index != 0 {
return None;
}
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
(first_output_for_source_page[source_index].get(&source_page_ref)
== Some(&final_refs[output_index]))
.then_some(final_refs[output_index])
})
.collect();
let had_fields_array = match sources.first_mut() {
Some(primary) => primary.acroform()?.has_fields_array()?,
None => false,
};
let primary_fields = collect_primary_fields(merged, &primary_first_pages)?;
replace_merged_fields(merged, primary_fields, had_fields_array)?;
for (source_index, mappings) in first_output_for_source_page.iter().enumerate() {
if mappings.is_empty() {
continue;
}
let source_id = sources[source_index].unique_id();
let mut object_map = merged.take_foreign_object_map(source_id);
object_map.extend(mappings.iter().map(|(&source, &target)| (source, target)));
merged.set_foreign_object_map(source_id, object_map);
}
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
let first_output_page = first_output_for_source_page[source_index]
.get(&source_page_ref)
.copied()
.ok_or(Error::Missing("first output page for source page"))?;
let is_primary_first = source_index == 0 && first_output_page == final_refs[output_index];
if is_primary_first || (!source_has_acroform[source_index] && source_index != 0) {
set_annotation_page_refs(merged, final_refs[output_index], first_output_page)?;
continue;
}
let destination_page = merged.get_object_handle(final_refs[output_index]);
destination_page.remove_key(b"/Annots");
merged.mark_object_handle_dirty(&destination_page)?;
if source_index == 0 {
let source_page = merged.get_object_handle(first_output_page);
PageObjectHelper::new(final_refs[output_index], merged)
.copy_annotations_with_field_tree_only(
source_page,
Matrix::default(),
&primary_field_names,
)?; } else {
let source_page = sources[source_index].get_object_handle(source_page_ref);
let source = &mut sources[source_index];
let mut destination = PageObjectHelper::new(final_refs[output_index], merged);
destination.copy_annotations_from_with_field_tree_only(
source_page,
Matrix::default(),
source,
&primary_field_names,
)?; }
}
Ok(())
}
fn merge_job_label_ranges(ranges: Vec<JobLabelEntry>) -> Vec<JobLabelEntry> {
let mut out: Vec<JobLabelEntry> = Vec::with_capacity(ranges.len());
for (idx, range, prefix_present) in ranges {
if let Some((previous_idx, previous, previous_prefix_present)) = out.last() {
let expected_start = idx
.checked_sub(*previous_idx)
.and_then(|gap| previous.start.checked_add(gap));
if let Some(expected_start) = expected_start {
if previous.style == range.style
&& previous.prefix == range.prefix
&& *previous_prefix_present == prefix_present
&& range.start == expected_start
{
continue;
}
}
}
out.push((idx, range, prefix_present));
}
out
}
fn handle_page_specs<R: Read + Seek + 'static>(
job: &mut super::QPDFJob,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<usize>,
resource_mode: RemoveUnreferencedResources,
preserve_unreferenced: bool,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if sources.is_empty() {
return Err(Error::Unsupported(
"--pages: a primary source document is required".into(),
));
}
if specs.is_empty() {
return Err(Error::Unsupported(
"--pages: no page specifications were supplied".into(),
));
}
if collate == Some(0) {
return Err(Error::Unsupported(
"--collate chunk size must be >= 1; got 0".into(),
));
}
let mut plans = Vec::with_capacity(specs.len());
for (spec_index, spec) in specs.iter().enumerate() {
let source = sources.get_mut(spec.source_index).ok_or_else(|| {
Error::Unsupported(format!(
"--pages: specification {spec_index} refers to missing source {}",
spec.source_index
))
})?;
let plan = PagePlan::build(source, &spec.range).map_err(|error| {
Error::Unsupported(format!(
"--pages: source {} specification {spec_index}: {error}",
spec.source_index
))
})?;
plans.push(plan);
}
let mut grouped_pages: Vec<Vec<usize>> = vec![Vec::new(); sources.len()];
let mut ordered_pages: Vec<OrderedPage> = Vec::new();
let mut append_page = |source_index: usize, page_index_1based: u32| {
let page_index = page_index_1based as usize - 1;
let group_index = grouped_pages[source_index].len();
grouped_pages[source_index].push(page_index);
ordered_pages.push((source_index, group_index));
};
if let Some(chunk) = collate {
let mut cursors = vec![0usize; plans.len()];
loop {
let mut emitted = false;
for (spec_index, plan) in plans.iter().enumerate() {
let start = cursors[spec_index];
let end = start.saturating_add(chunk).min(plan.pages().len());
for page in &plan.pages()[start..end] {
append_page(specs[spec_index].source_index, page.index_1based);
}
if end > start {
emitted = true;
}
cursors[spec_index] = end;
}
if !emitted {
break;
}
}
} else {
for (spec_index, plan) in plans.iter().enumerate() {
for page in plan.pages() {
append_page(specs[spec_index].source_index, page.index_1based);
}
}
}
if ordered_pages.is_empty() {
return Err(Error::Unsupported(
"--pages: page selection is empty".into(),
));
}
let mut any_page_labels = false;
for source in sources.iter_mut() {
any_page_labels |= source.page_labels().has_page_labels()?;
}
let mut label_entries = Vec::new();
if any_page_labels {
label_entries.reserve(ordered_pages.len());
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source = &mut sources[source_index];
let entries = source
.page_labels()
.labels_for_selection(&[source_page_index as i64], output_index as i64)?;
let prefix_present = source
.page_labels()
.label_prefix_is_present(source_page_index as i64)?;
if let Some(entry) = entries.into_iter().next() {
label_entries.push((entry.0, entry.1, prefix_present));
}
}
}
let mut merge_inputs: Vec<MergeInput<'_, R>> = sources
.iter_mut()
.zip(grouped_pages.iter())
.map(|(source, pages)| MergeInput {
source,
pages: pages.clone(),
})
.collect();
let mut merged = if preserve_unreferenced {
merge_preserving_primary(&mut merge_inputs, resource_mode)?
} else {
merge_documents_with_resource_mode(&mut merge_inputs, resource_mode)?
};
drop(merge_inputs);
let grouped_refs = crate::pages::page_refs(&mut merged)?;
if grouped_refs.len() != ordered_pages.len() {
return Err(Error::Unsupported(format!(
"--pages: merge produced {} pages for {} selected pages",
grouped_refs.len(),
ordered_pages.len()
)));
}
let offsets: Vec<usize> = grouped_pages
.iter()
.scan(0usize, |offset, pages| {
let current = *offset;
*offset += pages.len();
Some(current)
})
.collect();
let final_refs: Vec<_> = ordered_pages
.iter()
.map(|&(source_index, group_index)| grouped_refs[offsets[source_index] + group_index])
.collect();
if final_refs != grouped_refs {
crate::pages::tree_rebuild::rebuild_page_tree(&mut merged, &final_refs)?;
}
rebuild_acroform_in_final_page_order(
&mut merged,
sources,
&grouped_pages,
&ordered_pages,
&final_refs,
)?;
if any_page_labels {
let folded = merge_job_label_ranges(label_entries);
merged
.page_labels()
.write_reconstructed_labels_with_prefix_presence(&folded)?;
}
for source in sources.iter() {
job.record_document_warnings(source);
}
job.record_document_warnings(&merged);
Ok(merged)
}
impl super::QPDFJob {
pub fn prune_after_subset<R: Read + Seek>(
pdf: &mut Pdf<R>,
mode: RemoveUnreferencedResources,
) -> Result<()> {
super::page_subset::prune_after_subset(pdf, mode)
}
pub fn prune_acroform_after_subset<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> Result<()> {
super::acroform_field_prune::prune_acroform_after_subset(pdf, result)
}
pub fn handle_page_specs<R: Read + Seek + 'static>(
&mut self,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<usize>,
resource_mode: RemoveUnreferencedResources,
preserve_unreferenced: bool,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
handle_page_specs(
self,
sources,
specs,
collate,
resource_mode,
preserve_unreferenced,
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::job::QPDFJob;
use crate::page_label_document_helper::LabelStyle;
use crate::ObjectHandle;
use std::io::Cursor;
fn three_page_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/three-page.pdf").to_vec(),
)
.expect("open three-page fixture")
}
fn acroform_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/acroform-sig-widget.pdf").to_vec(),
)
.expect("open AcroForm fixture")
}
fn inherited_resources_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/inherited-resources-one-page.pdf")
.to_vec(),
)
.expect("open inherited-resources fixture")
}
fn labelled_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/json-diff/direct-outlines.pdf").to_vec(),
)
.expect("open labelled fixture")
}
fn assemble_pdf(objects: &[&[u8]]) -> Vec<u8> {
use std::io::Write;
let mut bytes = b"%PDF-1.4\n".to_vec();
let mut offsets = Vec::with_capacity(objects.len());
for object in objects {
offsets.push(bytes.len());
bytes.extend_from_slice(object);
}
let start_xref = bytes.len();
let _ = writeln!(&mut bytes, "xref\n0 {}", objects.len() + 1);
bytes.extend_from_slice(b"0000000000 65535 f \n");
for &offset in &offsets {
let _ = writeln!(&mut bytes, "{offset:010} 00000 n ");
}
let _ = writeln!(
&mut bytes,
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{}\n%%EOF",
objects.len() + 1,
start_xref
);
bytes
}
fn acroform_no_fields_array_pdf() -> Pdf<Cursor<Vec<u8>>> {
let bytes = assemble_pdf(&[
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R \
/AcroForm << /NeedAppearances true >> >>\nendobj\n",
b"2 0 obj\n<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n",
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
]);
Pdf::open_mem_owned(bytes).expect("open AcroForm-no-fields-array fixture")
}
fn acroform_all_fields_on_page_two_pdf() -> Pdf<Cursor<Vec<u8>>> {
let bytes = assemble_pdf(&[
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R \
/AcroForm << /Fields [5 0 R] /NeedAppearances true >> >>\nendobj\n",
b"2 0 obj\n<< /Type /Pages /Count 2 /Kids [3 0 R 4 0 R] >>\nendobj\n",
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
b"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [5 0 R] >>\nendobj\n",
b"5 0 obj\n<< /Type /Annot /Subtype /Widget /FT /Tx /T (Orphan) \
/Rect [0 0 10 10] /P 4 0 R >>\nendobj\n",
]);
Pdf::open_mem_owned(bytes).expect("open AcroForm-orphan-field fixture")
}
fn selected_page_count(pdf: &mut Pdf<Cursor<Vec<u8>>>) -> usize {
crate::pages::page_refs(pdf)
.expect("read merged page tree")
.len()
}
fn resolved_object(pdf: &mut Pdf<Cursor<Vec<u8>>>, object_ref: ObjectRef) -> ObjectHandle {
let object = pdf.get_object_handle(object_ref);
pdf.resolve(&object).expect("resolve object handle");
object
}
fn resolved_key(
pdf: &mut Pdf<Cursor<Vec<u8>>>,
owner: &ObjectHandle,
key: &[u8],
) -> ObjectHandle {
let value = owner.get_key(key);
pdf.resolve(&value).expect("resolve child handle");
value
}
fn pdf_without_root() -> Pdf<Cursor<Vec<u8>>> {
let mut pdf = Pdf::empty().expect("empty PDF");
pdf.trailer().remove_key(b"/Root");
assert!(pdf.root_ref().is_none());
pdf
}
#[test]
fn rebuild_acroform_ignores_a_missing_merged_root() {
let mut merged = pdf_without_root();
let mut sources: Vec<Pdf<Cursor<Vec<u8>>>> = Vec::new();
rebuild_acroform_in_final_page_order(&mut merged, &mut sources, &[], &[], &[])
.expect("a missing merged root has no AcroForm to rebuild");
}
#[test]
fn replace_merged_fields_ignores_a_missing_merged_root_when_gated_open() {
let mut merged = pdf_without_root();
replace_merged_fields(&mut merged, Vec::new(), true)
.expect("a missing merged root has no AcroForm to rebuild, even past the gate");
}
#[test]
fn replace_merged_fields_removes_acroform_when_no_fields_survive() {
let mut merged = acroform_pdf();
replace_merged_fields(&mut merged, Vec::new(), true)
.expect("an empty survivor list removes /AcroForm");
let root_ref = merged.root_ref().expect("root");
assert!(
resolved_object(&mut merged, root_ref)
.get_key(b"/AcroForm")
.is_null(),
"qpdf removes /AcroForm entirely once the filtered field count reaches zero"
);
}
#[test]
fn rebuild_acroform_propagates_annotation_copy_errors() {
let mut merged = three_page_pdf();
let invalid_final_ref = ObjectRef::new(999, 0);
let mut sources = vec![three_page_pdf()];
rebuild_acroform_in_final_page_order(
&mut merged,
&mut sources,
&[vec![0]],
&[(0, 0)],
&[invalid_final_ref],
)
.expect_err("an invalid destination page must escape the foreign copy route");
}
#[test]
fn rebuild_acroform_uses_foreign_copy_route_for_secondary_acroform() {
let mut merged = three_page_pdf();
let mut sources = vec![three_page_pdf(), acroform_pdf()];
rebuild_acroform_in_final_page_order(
&mut merged,
&mut sources,
&[vec![], vec![0]],
&[(1, 0)],
&[ObjectRef::new(3, 0)],
)
.expect("a secondary AcroForm page must use the foreign copy route");
}
#[test]
fn collect_primary_fields_ignores_direct_field_handles() {
let mut merged = three_page_pdf();
let page_ref = crate::pages::page_refs(&mut merged).unwrap()[0];
let page = merged.get_object_handle(page_ref);
let widget = ObjectHandle::dictionary(vec![
(b"Type".to_vec(), ObjectHandle::name(b"Annot".to_vec())),
(b"Subtype".to_vec(), ObjectHandle::name(b"Widget".to_vec())),
]);
page.replace_key(b"/Annots", ObjectHandle::array(vec![widget]))
.unwrap();
merged.mark_object_handle_dirty(&page).unwrap();
assert!(
collect_primary_fields(&mut merged, &[page_ref])
.unwrap()
.is_empty(),
"direct field handles have no stable top-level object identity"
);
}
#[test]
fn handle_page_specs_default_materializes_inherited_resources_like_qpdf() {
let mut sources = vec![inherited_resources_pdf()];
let specs = [PageSpecInput::new(0, PageRange::parse("1,1").unwrap())];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("merge inherited-resources page");
let page_refs = crate::pages::page_refs(&mut merged).expect("read merged page tree");
assert_eq!(page_refs.len(), 2);
for page_ref in page_refs {
let page = resolved_object(&mut merged, page_ref);
assert!(
page.get_key(b"/Resources").as_dictionary().is_some(),
"qpdf --pages default copies inherited /Resources directly onto the page"
);
}
}
#[test]
fn handle_page_specs_preserves_an_acroform_with_no_fields_array_across_sources() {
let mut sources = vec![acroform_no_fields_array_pdf(), three_page_pdf()];
let specs = [
PageSpecInput::new(0, PageRange::parse("1").unwrap()),
PageSpecInput::new(1, PageRange::parse("1").unwrap()),
];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("merge across a fields-less-AcroForm primary and a secondary source");
let root_ref = merged.root_ref().expect("merged root");
let root = resolved_object(&mut merged, root_ref);
let acroform = resolved_key(&mut merged, &root, b"/AcroForm");
assert_eq!(
resolved_key(&mut merged, &acroform, b"/NeedAppearances").as_boolean(),
Some(true)
);
assert!(
acroform.get_key(b"/Fields").is_null(),
"no /Fields array existed originally; the merge must not manufacture one"
);
}
#[test]
fn handle_page_specs_removes_acroform_when_the_only_field_page_is_unselected() {
let mut sources = vec![acroform_all_fields_on_page_two_pdf(), three_page_pdf()];
let specs = [
PageSpecInput::new(0, PageRange::parse("1").unwrap()),
PageSpecInput::new(1, PageRange::parse("1").unwrap()),
];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("merge with the only AcroForm field on an unselected page");
let root_ref = merged.root_ref().expect("merged root");
assert!(
resolved_object(&mut merged, root_ref)
.get_key(b"/AcroForm")
.is_null(),
"qpdf removes /AcroForm entirely once its filtered field count reaches zero"
);
}
#[test]
fn qpdf_job_owns_single_document_acroform_prune_boundary() {
let mut pdf = acroform_all_fields_on_page_two_pdf();
let original_pages = crate::pages::page_refs(&mut pdf).expect("original page refs");
let result = crate::pages::tree_rebuild::rebuild_page_tree(&mut pdf, &[original_pages[0]])
.expect("rebuild the selected page");
QPDFJob::prune_acroform_after_subset(&mut pdf, &result)
.expect("job-owned AcroForm pruning");
let root_ref = pdf.root_ref().expect("root");
assert!(
resolved_object(&mut pdf, root_ref)
.get_key(b"/AcroForm")
.is_null(),
"the job boundary must remove an empty AcroForm after page selection"
);
}
#[test]
fn page_spec_input_constructor_keeps_source_and_range() {
let range = PageRange::parse("1-2").unwrap();
assert_eq!(PageSpecInput::new(3, range.clone()).source_index, 3);
assert_eq!(
PageSpecInput::new(3, range).range,
PageRange::parse("1-2").unwrap()
);
}
#[test]
fn handle_page_specs_rejects_invalid_job_inputs_and_selections() {
let mut no_sources: Vec<Pdf<Cursor<Vec<u8>>>> = Vec::new();
let spec = [PageSpecInput::new(0, PageRange::parse("1").unwrap())];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut no_sources,
&spec,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&[],
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&spec,
Some(0),
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
let missing = [PageSpecInput::new(1, PageRange::parse("1").unwrap())];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&missing,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
let out_of_range = [PageSpecInput::new(0, PageRange::parse("99").unwrap())];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&out_of_range,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
let empty = [PageSpecInput::new(0, PageRange::empty())];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&empty,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
}
#[test]
fn handle_page_specs_restores_cross_source_order_and_collates() {
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let reversed = [
PageSpecInput::new(1, PageRange::parse("1").unwrap()),
PageSpecInput::new(0, PageRange::parse("1").unwrap()),
];
let mut reversed_output = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&reversed,
None,
RemoveUnreferencedResources::Auto,
false,
)
.unwrap();
assert_eq!(selected_page_count(&mut reversed_output), 2);
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let collated = [
PageSpecInput::new(0, PageRange::parse("1-2").unwrap()),
PageSpecInput::new(1, PageRange::parse("1-2").unwrap()),
];
let mut collated_output = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&collated,
Some(1),
RemoveUnreferencedResources::Auto,
false,
)
.unwrap();
assert_eq!(selected_page_count(&mut collated_output), 4);
}
#[test]
fn handle_page_specs_reconstructs_qpdf_page_labels_with_empty_prefix() {
let mut sources = vec![labelled_pdf()];
let specs = [PageSpecInput::new(0, PageRange::parse("1-2").unwrap())];
let mut output = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.unwrap();
let catalog_ref = output.root_ref().unwrap();
let catalog = resolved_object(&mut output, catalog_ref);
let page_labels = resolved_key(&mut output, &catalog, b"/PageLabels");
let nums = resolved_key(&mut output, &page_labels, b"/Nums")
.as_array()
.expect("merged PageLabels /Nums must be an array");
let first_label = nums.get(1).cloned().expect("first reconstructed label");
output
.resolve(&first_label)
.expect("resolve first reconstructed label");
assert_eq!(first_label.get_key(b"/P").as_string(), Some(Vec::new()));
}
#[test]
fn merge_job_label_ranges_preserves_prefix_presence_and_checked_arithmetic() {
let decimal = |start| LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start,
};
let merged = merge_job_label_ranges(vec![(0, decimal(1), true), (1, decimal(2), true)]);
assert_eq!(merged.len(), 1);
let prefix_presence_mismatch =
merge_job_label_ranges(vec![(0, decimal(1), true), (1, decimal(2), false)]);
assert_eq!(prefix_presence_mismatch.len(), 2);
let underflow =
merge_job_label_ranges(vec![(1, decimal(1), false), (0, decimal(1), false)]);
assert_eq!(underflow.len(), 2);
let overflow =
merge_job_label_ranges(vec![(0, decimal(i64::MAX), false), (1, decimal(0), false)]);
assert_eq!(overflow.len(), 2);
}
}