use super::page_merge::{
merge_documents_with_resource_decisions_and_preserve_primary, source_top_level_field_names,
MergeInput,
};
use super::page_plan::PagePlan;
use super::resource_pruning::{
shared_resource_finding_message, should_remove_unreferenced_resources_with_report,
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, UsageError,
};
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,
}
pub enum PageSpecJobOutput<'a, R: Read + Seek + 'static> {
InPlace {
pdf: &'a mut Pdf<R>,
result: RebuildResult,
prune_mode: RemoveUnreferencedResources,
},
Merged(Box<Pdf<std::io::Cursor<Vec<u8>>>>),
}
fn select_single_source_pages<R: Read + Seek>(
source: &mut Pdf<R>,
specs: &[PageSpecInput],
collate: Option<&[usize]>,
) -> Result<Vec<super::page_plan::SelectedPage>> {
if specs.is_empty() {
return Err(Error::Unsupported(
"--pages: no page specifications were supplied".into(),
));
}
let mut plans = Vec::with_capacity(specs.len());
for (spec_index, spec) in specs.iter().enumerate() {
if spec.source_index != 0 {
return Err(Error::Unsupported(format!(
"--pages: single-source specification {spec_index} refers to source {}",
spec.source_index
)));
}
plans.push(PagePlan::build(source, &spec.range).map_err(|error| {
Error::Unsupported(format!(
"--pages: source 0 specification {spec_index}: {error}"
))
})?);
}
let mut selected = Vec::new();
let collate_values = collate_values_for_specs(collate, plans.len())?;
if plans.len() > 1 {
if let Some(values) = collate_values.as_deref() {
let mut cursors = vec![0usize; plans.len()];
loop {
let mut emitted = false;
for (plan_index, plan) in plans.iter().enumerate() {
let start = cursors[plan_index];
let end = start
.saturating_add(values[plan_index])
.min(plan.pages().len());
selected.extend(plan.pages()[start..end].iter().cloned());
emitted |= end > start;
cursors[plan_index] = end;
}
if !emitted {
break;
}
}
} else {
selected.extend(plans.iter().flat_map(|plan| plan.pages().iter().cloned()));
}
} else {
selected.extend(plans.iter().flat_map(|plan| plan.pages().iter().cloned()));
}
let allows_empty_selection = plans.len() > 1
&& collate_values
.as_ref()
.is_some_and(|values| values.iter().all(|&value| value == 0));
if selected.is_empty() && !allows_empty_selection {
return Err(Error::Unsupported(
"--pages: page selection is empty".into(),
));
}
Ok(selected)
}
fn collate_values_for_specs(
collate: Option<&[usize]>,
spec_count: usize,
) -> Result<Option<Vec<usize>>> {
let Some(values) = collate else {
return Ok(None);
};
if values.is_empty() {
return Ok(None);
}
if values.len() != 1 && values.len() != spec_count {
return Err(Error::Usage(UsageError::new(
"--pages: if --collate has more than one value, it must have one value per page specification",
)));
}
if values.len() == 1 && spec_count > 1 {
return Ok(Some(vec![values[0]; spec_count]));
}
Ok(Some(values.to_vec()))
}
pub fn copy_duplicate_page_annotations<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> Result<()> {
let mut first_occurrence: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
for page_refs in result.ref_map.values() {
let Some(&first_page) = page_refs.first() else {
continue; };
for &duplicate_page in page_refs.iter().skip(1) {
first_occurrence.insert(duplicate_page, first_page);
}
}
for &new_page in &result.new_kids {
let Some(&source_page_ref) = first_occurrence.get(&new_page) else {
continue;
};
let source_page = pdf.get_object_handle(source_page_ref);
let destination_page = pdf.get_object_handle(new_page);
destination_page.remove_key(b"/Annots");
pdf.mark_object_handle_dirty(&destination_page)?;
PageObjectHelper::new(new_page, pdf).copy_annotations(source_page, Matrix::default())?;
}
Ok(())
}
fn prefixed_info_line(job: &super::QPDFJob, body: &[u8]) -> Vec<u8> {
let mut message = job.message_prefix().as_bytes().to_vec();
message.extend_from_slice(b": ");
message.extend_from_slice(body);
message
}
fn report_page_spec_diagnostics<R: Read + Seek>(
job: &super::QPDFJob,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
resource_mode: RemoveUnreferencedResources,
) -> Result<Vec<bool>> {
let source_names: Vec<Vec<u8>> = sources.iter().map(Pdf::input_source_description).collect();
let mut source_order: Vec<(usize, Vec<u8>)> = source_names
.iter()
.enumerate()
.map(|(index, name)| (index, job.page_spec_source_sort_key(index, name)))
.collect();
source_order.sort_by(|(left_index, left_name), (right_index, right_name)| {
left_name
.cmp(right_name)
.then_with(|| left_index.cmp(right_index))
});
let verbose = job.verbose();
let logger = job.logger();
let mut decisions = vec![false; sources.len()];
let mut decisions_by_source_id = BTreeMap::new();
for (source_index, _source_sort_key) in source_order {
let source_name = &source_names[source_index];
let source_id = sources[source_index].unique_id();
if let Some(&decision) = decisions_by_source_id.get(&source_id) {
decisions[source_index] = decision;
continue;
}
let decision = match resource_mode {
RemoveUnreferencedResources::No => false,
RemoveUnreferencedResources::Yes => true,
RemoveUnreferencedResources::Auto => {
if verbose {
let mut message = prefixed_info_line(job, source_name.as_slice());
message.extend_from_slice(b": checking for shared resources\n");
logger.info(message)?;
}
let should_remove = should_remove_unreferenced_resources_with_report(
&mut sources[source_index],
|finding| {
if verbose {
logger.info(shared_resource_finding_message(finding))
} else {
Ok(())
}
},
)?; if verbose && !should_remove {
logger.info(prefixed_info_line(job, b"no shared resources found\n"))?;
}
should_remove
}
};
decisions_by_source_id.insert(source_id, decision);
decisions[source_index] = decision;
}
if verbose {
logger.info(prefixed_info_line(
job,
b"removing unreferenced pages from primary input\n",
))?; for spec in specs {
let source_name = source_names.get(spec.source_index).ok_or_else(|| {
Error::Unsupported(format!(
"--pages: specification refers to missing source {}",
spec.source_index
))
})?;
let mut message = prefixed_info_line(job, b"adding pages from ");
message.extend_from_slice(source_name);
message.push(b'\n');
logger.info(message)?;
}
}
Ok(decisions)
}
fn handle_single_source_page_specs<R: Read + Seek>(
job: &mut super::QPDFJob,
source: &mut Pdf<R>,
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
) -> Result<(RebuildResult, RemoveUnreferencedResources)> {
crate::PageDocumentHelper::new(source).get_all_pages()?;
let selected = select_single_source_pages(source, specs, collate)?;
let remove_resources =
report_page_spec_diagnostics(job, std::slice::from_mut(source), specs, resource_mode)?;
let prune_mode = if remove_resources[0] {
resource_mode
} else {
RemoveUnreferencedResources::No
};
crate::PageDocumentHelper::new(source).push_inherited_attributes_to_pages()?;
let selected_refs: Vec<_> = selected.iter().map(|page| page.page_ref).collect();
let result = crate::pages::tree_rebuild::rebuild_page_tree(source, &selected_refs)?;
copy_duplicate_page_annotations(source, &result)?;
let mut labels = source.page_labels();
if labels.has_page_labels()? {
let src_indices: Vec<i64> = selected
.iter()
.map(|page| i64::from(page.index_1based) - 1)
.collect();
let entries = labels.labels_for_selection_with_prefix_presence(&src_indices, 0)?;
let folded = crate::merge_adjacent_ranges_with_prefix_presence(entries);
labels.write_reconstructed_labels_with_prefix_presence(&folded)?;
}
job.record_document_warnings(source);
Ok((result, prune_mode))
}
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>],
remove_resources: &[bool],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
merge_documents_with_resource_decisions_and_preserve_primary(inputs, remove_resources, 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 clear_grouped_foreign_fields_for_replay(merged: &mut Pdf<Cursor<Vec<u8>>>) -> Result<()> {
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")?)?;
if acroform.try_as_dictionary()?.is_none() {
return Ok(());
}
let fields = merged.resolve_handle(&acroform.try_get_key(b"/Fields")?)?;
if fields.try_as_array()?.is_none() {
return Ok(());
}
acroform.replace_key(b"/Fields", ObjectHandle::array(Vec::new()))?;
merged.mark_object_handle_dirty(&acroform)
}
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>],
source_page_refs: &[Vec<ObjectRef>],
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_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)?;
if !had_fields_array {
clear_grouped_foreign_fields_for_replay(merged)?;
}
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(),
));
}
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 collate_values = collate_values_for_specs(collate, plans.len())?;
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 plans.len() > 1 {
if let Some(values) = collate_values.as_deref() {
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(values[spec_index])
.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);
}
}
}
} else {
for (spec_index, plan) in plans.iter().enumerate() {
for page in plan.pages() {
append_page(specs[spec_index].source_index, page.index_1based);
}
}
}
let allows_empty_selection = plans.len() > 1
&& collate_values
.as_ref()
.is_some_and(|values| values.iter().all(|&value| value == 0));
if ordered_pages.is_empty() && !allows_empty_selection {
return Err(Error::Unsupported(
"--pages: page selection is empty".into(),
));
}
let remove_resources = report_page_spec_diagnostics(job, sources, specs, resource_mode)?;
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 source_page_refs: Vec<Vec<ObjectRef>> = sources
.iter_mut()
.enumerate()
.map(|(source_index, source)| {
if source_index != 0 && grouped_pages[source_index].is_empty() {
Ok(Vec::new())
} else {
crate::pages::page_refs(source)
}
})
.collect::<Result<_>>()?;
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, &remove_resources)?
} else {
merge_documents_with_resource_decisions_and_preserve_primary(
&mut merge_inputs,
&remove_resources,
false,
)? };
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,
&source_page_refs,
&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 complete_in_place_page_selection<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
prune_mode: RemoveUnreferencedResources,
) -> Result<()> {
super::outline_dest_remap::remap_outline_and_dests(pdf, result)?;
let objr_obj_targets = crate::drop_struct_elem_dangling_pg(pdf, result)?;
crate::drop_thread_bead_dangling_p(pdf, result)?;
crate::drop_objr_obj_annot_dangling_p(pdf, result, &objr_obj_targets)?;
super::page_subset::prune_after_subset(pdf, prune_mode)?;
super::acroform_field_prune::prune_acroform_after_subset(pdf, result)
}
pub fn handle_page_specs<'a, R: Read + Seek + 'static>(
&mut self,
sources: &'a mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
preserve_unreferenced: bool,
) -> Result<PageSpecJobOutput<'a, R>> {
let keep_files_open = self.keep_files_open_for_page_specs(specs);
for (source_index, source) in sources.iter().enumerate().skip(1) {
if specs.iter().any(|spec| spec.source_index == source_index) {
source.set_input_source_stay_open(keep_files_open);
}
}
if sources.len() == 1 && specs.iter().all(|spec| spec.source_index == 0) {
let source = sources.first_mut().ok_or_else(|| {
Error::Unsupported("--pages: a primary source is required".to_owned())
})?;
let (result, prune_mode) =
handle_single_source_page_specs(self, source, specs, collate, resource_mode)?;
return Ok(PageSpecJobOutput::InPlace {
pdf: source,
result,
prune_mode,
});
}
handle_page_specs(
self,
sources,
specs,
collate,
resource_mode,
preserve_unreferenced,
)
.map(|merged| PageSpecJobOutput::Merged(Box::new(merged)))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::job::QPDFJob;
use crate::page_label_document_helper::LabelStyle;
use crate::pipeline::{Pipeline, PipelineHandle, PipelineResult};
use crate::{ObjectHandle, QPDFLogger};
use std::io::Cursor;
use std::sync::{Arc, Mutex};
struct RecordingInfoSink {
bytes: Arc<Mutex<Vec<u8>>>,
}
impl Pipeline for RecordingInfoSink {
fn identifier(&self) -> &str {
"page-spec info capture"
}
fn write(&mut self, data: &[u8]) -> PipelineResult<()> {
self.bytes.lock().unwrap().extend_from_slice(data);
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
fn verbose_job() -> (QPDFJob, Arc<Mutex<Vec<u8>>>) {
let bytes = Arc::new(Mutex::new(Vec::new()));
let logger = QPDFLogger::create();
logger.set_info(Some(PipelineHandle::new(RecordingInfoSink {
bytes: Arc::clone(&bytes),
})));
logger.set_warn(Some(logger.discard()));
logger.set_error(Some(logger.discard()));
let mut job = QPDFJob::new();
job.set_logger(logger);
job.set_message_prefix("qpdf");
job.set_verbose(true);
(job, bytes)
}
#[test]
fn recording_info_sink_implements_the_pipeline_contract() {
let bytes = Arc::new(Mutex::new(Vec::new()));
let mut sink = RecordingInfoSink {
bytes: Arc::clone(&bytes),
};
assert_eq!(sink.identifier(), "page-spec info capture");
sink.write(b"probe\n").unwrap();
sink.finish().unwrap();
assert_eq!(&*bytes.lock().unwrap(), b"probe\n");
}
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")
}
#[test]
fn page_spec_report_reuses_one_decision_per_source_identity() {
let (job, output) = verbose_job();
let inherited = inherited_resources_pdf();
let mut duplicate_identity = three_page_pdf();
duplicate_identity.unique_id = inherited.unique_id;
let range = PageRange::parse("1").expect("one-page range");
let specs = [
PageSpecInput::new(0, range.clone()),
PageSpecInput::new(1, range),
];
let mut sources = [inherited, duplicate_identity];
let decisions = report_page_spec_diagnostics(
&job,
&mut sources,
&specs,
RemoveUnreferencedResources::Auto,
)
.expect("resource report");
assert_eq!(decisions, [true, true]);
let output = output.lock().unwrap().clone();
assert!(
output
.windows(b"found resources in non-leaf page node".len())
.any(|window| window == b"found resources in non-leaf page node"),
"verbose report must include the first finding: {output:?}"
);
assert_eq!(
output
.windows(b"checking for shared resources".len())
.filter(|window| window == b"checking for shared resources")
.count(),
1,
"a repeated source identity is preflighted once: {output:?}"
);
}
#[test]
fn page_spec_report_rejects_a_missing_source_after_reporting_preflight() {
let (job, _output) = verbose_job();
let mut source = three_page_pdf();
let specs = [PageSpecInput::new(
1,
PageRange::parse("1").expect("one-page range"),
)];
assert!(matches!(
report_page_spec_diagnostics(
&job,
std::slice::from_mut(&mut source),
&specs,
RemoveUnreferencedResources::Auto,
),
Err(Error::Unsupported(message))
if message == "--pages: specification refers to missing source 1"
));
}
#[test]
fn empty_primary_keeps_qpdf_map_key_separate_from_display_name() {
let mut job = QPDFJob::new();
let empty = job.create_empty_document().expect("empty primary");
let description = empty.input_source_description();
assert_eq!(description, b"empty PDF");
assert!(job.page_spec_source_sort_key(0, &description).is_empty());
assert_eq!(job.page_spec_source_sort_key(1, b"empty PDF"), b"empty PDF");
}
#[test]
fn page_spec_job_uses_the_non_preserving_merge_decision_route() {
let primary = three_page_pdf();
let secondary = inherited_resources_pdf();
let range = PageRange::parse("1").expect("one-page range");
let specs = [
PageSpecInput::new(0, range.clone()),
PageSpecInput::new(1, range),
];
let mut sources = [primary, secondary];
let mut job = QPDFJob::new();
let output = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("multi-source page job");
assert!(matches!(output, PageSpecJobOutput::Merged(_)));
}
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 selected_indices(
source: &mut Pdf<Cursor<Vec<u8>>>,
specs: &[PageSpecInput],
collate: Option<&[usize]>,
) -> Vec<u32> {
select_single_source_pages(source, specs, collate)
.expect("valid page specifications")
.into_iter()
.map(|page| page.index_1based)
.collect()
}
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()];
let source_page_refs = sources
.iter_mut()
.map(crate::pages::page_refs)
.collect::<Result<Vec<_>>>()
.unwrap();
rebuild_acroform_in_final_page_order(
&mut merged,
&mut sources,
&source_page_refs,
&[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()];
let source_page_refs = sources
.iter_mut()
.map(crate::pages::page_refs)
.collect::<Result<Vec<_>>>()
.unwrap();
rebuild_acroform_in_final_page_order(
&mut merged,
&mut sources,
&source_page_refs,
&[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_skips_an_unused_secondary_source() {
let mut sources = vec![three_page_pdf(), pdf_without_root()];
let specs = [PageSpecInput::new(0, PageRange::parse("1").unwrap())];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("an unused secondary source must not be read");
assert_eq!(selected_page_count(&mut merged), 1);
}
#[test]
fn qpdf_job_keeps_a_single_source_page_job_in_place() {
let mut sources = vec![three_page_pdf()];
let specs = [PageSpecInput::new(0, PageRange::parse("2").unwrap())];
let mut job = QPDFJob::new();
let output = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("single-source page job");
assert!(matches!(&output, PageSpecJobOutput::InPlace { .. }));
if let PageSpecJobOutput::InPlace {
pdf,
result,
prune_mode: _,
} = output
{
assert_eq!(result.new_kids.len(), 1);
assert_eq!(selected_page_count(pdf), 1);
assert!(pdf
.repair_diagnostics()
.entries()
.iter()
.all(|entry| !entry.message.contains("foreign object")));
} }
#[test]
fn qpdf_job_in_place_page_job_copies_repeated_page_annotations() {
let mut sources = vec![acroform_pdf()];
let specs = [
PageSpecInput::new(0, PageRange::parse("1").unwrap()),
PageSpecInput::new(0, PageRange::parse("1").unwrap()),
];
let mut job = QPDFJob::new();
let output = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("repeated single-source page job");
assert!(matches!(&output, PageSpecJobOutput::InPlace { .. }));
if let PageSpecJobOutput::InPlace { pdf, result, .. } = output {
assert_eq!(result.new_kids.len(), 2);
assert_eq!(selected_page_count(pdf), 2);
} }
#[test]
fn single_source_page_planner_reports_its_input_errors() {
let mut source = three_page_pdf();
assert!(select_single_source_pages(&mut source, &[], None).is_err());
assert!(select_single_source_pages(
&mut source,
&[PageSpecInput::new(0, PageRange::parse("1").unwrap())],
Some(&[1, 2]),
)
.is_err());
assert!(select_single_source_pages(
&mut source,
&[PageSpecInput::new(1, PageRange::parse("1").unwrap())],
None,
)
.is_err());
assert!(select_single_source_pages(
&mut source,
&[PageSpecInput::new(0, PageRange::parse("999").unwrap())],
None,
)
.is_err());
}
#[test]
fn collate_value_cardinality_matches_qpdf() {
assert_eq!(collate_values_for_specs(None, 2).unwrap(), None);
assert_eq!(collate_values_for_specs(Some(&[]), 2).unwrap(), None);
assert_eq!(
collate_values_for_specs(Some(&[2]), 2).unwrap(),
Some(vec![2, 2])
);
assert_eq!(
collate_values_for_specs(Some(&[2, 3]), 2).unwrap(),
Some(vec![2, 3])
);
assert!(collate_values_for_specs(Some(&[1, 2, 3]), 2).is_err());
}
#[test]
fn single_source_page_planner_applies_qpdf_collate_values_per_spec() {
let specs = [
PageSpecInput::new(0, PageRange::parse("1-3").unwrap()),
PageSpecInput::new(0, PageRange::parse("1-3").unwrap()),
];
let mut source = three_page_pdf();
assert_eq!(
selected_indices(&mut source, &specs, Some(&[2, 1])),
vec![1, 2, 1, 3, 2, 3]
);
let mut source = three_page_pdf();
assert_eq!(
selected_indices(&mut source, &specs, Some(&[2])),
vec![1, 2, 1, 2, 3, 3]
);
let mut source = three_page_pdf();
assert!(selected_indices(&mut source, &specs, Some(&[0])).is_empty());
let mut source = three_page_pdf();
assert_eq!(
selected_indices(&mut source, &specs, Some(&[0, 1])),
vec![1, 2, 3]
);
let mut source = three_page_pdf();
let single_spec = [PageSpecInput::new(0, PageRange::parse("1").unwrap())];
assert_eq!(
selected_indices(&mut source, &single_spec, Some(&[0])),
vec![1]
);
let mut source = three_page_pdf();
assert!(select_single_source_pages(&mut source, &specs, Some(&[1, 2, 3])).is_err());
}
#[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()];
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_accepts_per_spec_and_zero_collate_values() {
let specs = [
PageSpecInput::new(0, PageRange::parse("1-3").unwrap()),
PageSpecInput::new(1, PageRange::parse("1-3").unwrap()),
];
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let mut per_spec = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
Some(&[2, 3]),
RemoveUnreferencedResources::Auto,
false,
)
.expect("per-spec collate values are valid");
assert_eq!(selected_page_count(&mut per_spec), 6);
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let mut second_only = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
Some(&[0, 1]),
RemoveUnreferencedResources::Auto,
false,
)
.expect("zero collate value is valid");
assert_eq!(selected_page_count(&mut second_only), 3);
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let mut empty = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
Some(&[0]),
RemoveUnreferencedResources::Auto,
false,
)
.expect("all-zero collate value is valid");
assert_eq!(selected_page_count(&mut empty), 0);
}
#[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);
}
}