use crate::nntree::DEFAULT_MAX_TREE_DEPTH;
use crate::{Error, ObjectHandle, Pdf, Result};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LabelStyle {
Decimal,
RomanUpper,
RomanLower,
AlphaUpper,
AlphaLower,
None,
}
impl LabelStyle {
pub fn from_name(name: &[u8]) -> Self {
match name {
b"D" => LabelStyle::Decimal,
b"R" => LabelStyle::RomanUpper,
b"r" => LabelStyle::RomanLower,
b"A" => LabelStyle::AlphaUpper,
b"a" => LabelStyle::AlphaLower,
_ => LabelStyle::None,
}
}
pub fn to_name(self) -> Option<&'static str> {
match self {
LabelStyle::Decimal => Some("D"),
LabelStyle::RomanUpper => Some("R"),
LabelStyle::RomanLower => Some("r"),
LabelStyle::AlphaUpper => Some("A"),
LabelStyle::AlphaLower => Some("a"),
LabelStyle::None => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LabelRange {
pub style: LabelStyle,
pub prefix: String,
pub start: i64,
}
pub(crate) struct RawPageLabelEntry {
pub(crate) index: i64,
pub(crate) source_id: u64,
pub(crate) source_is_primary: bool,
pub(crate) label: ObjectHandle,
}
impl LabelRange {
fn from_handle(handle: &ObjectHandle) -> Result<Option<Self>> {
let handle = handle.clone();
handle.try_dereference()?;
if !handle.try_is_dictionary()? {
return Ok(None);
}
let style = handle
.try_get_key(b"/S")?
.try_as_name()?
.map(|name| LabelStyle::from_name(&name))
.unwrap_or(LabelStyle::None);
let prefix_handle = handle.try_get_key(b"/P")?;
prefix_handle.try_dereference()?;
let prefix_bytes = prefix_handle.as_string().unwrap_or_default();
let prefix = crate::json_inspect::decode_pdf_text_string(&prefix_bytes)
.unwrap_or_else(|| String::from_utf8_lossy(&prefix_bytes).into_owned());
let start = handle.try_get_key(b"/St")?.try_as_integer()?.unwrap_or(1);
Ok(Some(Self {
style,
prefix,
start,
}))
}
}
fn raw_page_labels_are_redundant(
previous_index: i64,
previous: &ObjectHandle,
index: i64,
current: &ObjectHandle,
) -> Result<bool> {
let previous_st = previous.try_get_key(b"/St")?.try_as_integer()?;
let current_st = current.try_get_key(b"/St")?.try_as_integer()?;
let expected_start = index
.checked_sub(previous_index)
.and_then(|gap| previous_st.and_then(|start| start.checked_add(gap)));
Ok(match (expected_start, current_st) {
(Some(expected_start), Some(current_st)) => {
current_st == expected_start
&& previous.try_get_key(b"/S")?.unparse() == current.try_get_key(b"/S")?.unparse()
&& previous.try_get_key(b"/P")?.unparse() == current.try_get_key(b"/P")?.unparse()
}
_ => false,
})
}
pub(crate) fn merge_adjacent_raw_labels(
ranges: Vec<(i64, ObjectHandle)>,
) -> Result<Vec<(i64, ObjectHandle)>> {
let mut out = Vec::with_capacity(ranges.len());
for range in ranges {
if let Some((previous_index, previous)) = out.last() {
if raw_page_labels_are_redundant(*previous_index, previous, range.0, &range.1)? {
continue;
}
}
out.push(range);
}
Ok(out)
}
pub(crate) fn merge_adjacent_raw_page_labels(
ranges: Vec<RawPageLabelEntry>,
) -> Result<Vec<RawPageLabelEntry>> {
let mut out: Vec<RawPageLabelEntry> = Vec::with_capacity(ranges.len());
for range in ranges {
if let Some(previous) = out.last() {
let redundant = raw_page_labels_are_redundant(
previous.index,
&previous.label,
range.index,
&range.label,
)?; if redundant {
continue;
}
}
out.push(range);
}
Ok(out)
}
pub(crate) fn copy_raw_page_label_entries<R: Read + Seek>(
target: &mut Pdf<R>,
ranges: &[RawPageLabelEntry],
) -> Result<Vec<(i64, ObjectHandle)>> {
ranges
.iter()
.map(|range| {
let label = if range.source_is_primary {
target.copy_foreign_value(range.source_id, &range.label)?
} else {
range.label.shallow_copy()?
};
Ok((range.index, label))
})
.collect()
}
pub(crate) fn record_primary_label_provenance<R: Read + Seek>(
target: &mut Pdf<R>,
ranges: &[RawPageLabelEntry],
) {
let mut recorded = BTreeSet::new();
for range in ranges.iter().filter(|range| range.source_is_primary) {
if recorded.insert(range.source_id) {
target.record_primary_writer_object_refs(range.source_id);
}
}
}
pub struct PageLabelDocumentHelper<'a, R: Read + Seek + 'static> {
pdf: &'a mut Pdf<R>,
}
impl<'a, R: Read + Seek> PageLabelDocumentHelper<'a, R> {
pub fn new(pdf: &'a mut Pdf<R>) -> Self {
Self { pdf }
}
fn pagelabels_root_handle(&mut self) -> Result<Option<ObjectHandle>> {
let catalog = self.pdf.root_handle()?;
if !catalog.try_has_key(b"/PageLabels")? {
return Ok(None);
}
Ok(Some(catalog.try_get_key(b"/PageLabels")?))
}
fn pagelabels_tree(&mut self) -> Result<Option<crate::nntree::NumberTree>> {
let Some(root) = self.pagelabels_root_handle()? else {
return Ok(None);
};
let mut tree = crate::nntree::NumberTree::new(root, true);
tree.set_max_depth(DEFAULT_MAX_TREE_DEPTH);
Ok(Some(tree))
}
pub fn has_page_labels(&mut self) -> Result<bool> {
Ok(self.pagelabels_root_handle()?.is_some())
}
pub fn page_label_dict(style: LabelStyle, start_num: i64, prefix: &str) -> ObjectHandle {
Self::page_label_dict_bytes(style, start_num, prefix.as_bytes())
}
pub fn page_label_dict_bytes(style: LabelStyle, start_num: i64, prefix: &[u8]) -> ObjectHandle {
let result = ObjectHandle::dictionary(Vec::new());
if let Some(name) = style.to_name() {
result
.replace_key(b"/S", ObjectHandle::name(name.as_bytes().to_vec()))
.expect("new direct page-label dictionary is unowned");
}
if !prefix.is_empty() {
let bytes = crate::pdf_string::new_unicode_string(prefix);
result
.replace_key(b"/P", ObjectHandle::string(bytes))
.expect("new direct page-label dictionary is unowned");
}
if start_num != 1 {
result
.replace_key(b"/St", ObjectHandle::integer(start_num))
.expect("new direct page-label dictionary is unowned");
}
result
}
fn reconstructed_label_handle(
range: &LabelRange,
prefix_present: bool,
) -> Result<ObjectHandle> {
let result = Self::page_label_dict(range.style, range.start, &range.prefix);
if prefix_present && range.prefix.is_empty() {
result.replace_key(b"/P", ObjectHandle::string(Vec::new()))?;
}
result.replace_key(b"/St", ObjectHandle::integer(range.start))?;
Ok(result)
}
pub fn ranges(&mut self) -> Result<Vec<(i64, LabelRange)>> {
let Some(mut tree) = self.pagelabels_tree()? else {
return Ok(vec![]);
};
let raw_entries = tree.as_map(self.pdf)?;
let mut entries = Vec::with_capacity(raw_entries.len());
for (index, value) in raw_entries {
if let Some(range) = LabelRange::from_handle(&value)? {
entries.push((index, range));
}
}
Ok(entries)
}
pub fn label_for_page(&mut self, page_idx: i64) -> Result<Option<LabelRange>> {
let Some(label) = self.get_label_for_page(page_idx)? else {
return Ok(None);
};
LabelRange::from_handle(&label)
}
pub fn get_label_for_page(&mut self, page_idx: i64) -> Result<Option<ObjectHandle>> {
let Some(mut tree) = self.pagelabels_tree()? else {
return Ok(None);
};
self.get_label_for_page_from_tree(&mut tree, page_idx)
}
pub fn get_labels_for_page_range(
&mut self,
start_idx: i64,
end_idx: i64,
new_start_idx: i64,
labels: &mut Vec<(i64, ObjectHandle)>,
) -> Result<()> {
let idx_offset = new_start_idx
.checked_sub(start_idx)
.ok_or_else(|| Error::Unsupported("page label index offset overflow".to_string()))?;
let mut tree = self.pagelabels_tree()?;
let first_label = match tree.as_mut() {
Some(tree) => self
.get_label_for_page_from_tree(tree, start_idx)?
.unwrap_or_else(|| ObjectHandle::dictionary(Vec::new())),
None => ObjectHandle::dictionary(Vec::new()),
};
if !first_label.try_has_key(b"/St")? {
let default_start = new_start_idx.checked_add(1).ok_or_else(|| {
Error::Unsupported("page label fabricated start overflow".to_string())
})?;
first_label.replace_key(b"/St", ObjectHandle::integer(default_start))?;
}
let skip_first = if let Some((last_index, last_label)) = labels.last() {
if last_label.try_is_dictionary()? && first_label.try_is_dictionary()? {
let last_s = last_label.try_get_key(b"/S")?;
let first_s = first_label.try_get_key(b"/S")?;
let last_p = last_label.try_get_key(b"/P")?;
let first_p = first_label.try_get_key(b"/P")?;
let last_st = last_label.try_get_key(b"/St")?.try_as_integer()?;
let first_st = first_label.try_get_key(b"/St")?.try_as_integer()?;
let idx_delta = new_start_idx.checked_sub(*last_index);
let st_delta = first_st
.and_then(|first_st| last_st.and_then(|last_st| first_st.checked_sub(last_st)));
idx_delta.zip(st_delta).is_some_and(|(idx, st)| {
idx == st
&& last_s.unparse() == first_s.unparse()
&& last_p.unparse() == first_p.unparse()
})
} else {
false
}
} else {
false
};
if !skip_first {
labels.push((new_start_idx, first_label));
}
if let Some(tree) = tree.as_mut() {
let mut source_idx = start_idx;
while source_idx < end_idx {
source_idx = source_idx.checked_add(1).ok_or_else(|| {
Error::Unsupported("page label source index overflow".to_string())
})?; if !tree.has_index(self.pdf, source_idx)? {
continue;
}
let Some(label) = self.get_label_for_page_from_tree(tree, source_idx)? else {
continue;
};
let output_idx = source_idx.checked_add(idx_offset).ok_or_else(|| {
Error::Unsupported("page label output index overflow".to_string())
})?;
labels.push((output_idx, label));
}
}
Ok(())
}
fn get_label_for_page_from_tree(
&mut self,
tree: &mut crate::nntree::NumberTree,
page_idx: i64,
) -> Result<Option<ObjectHandle>> {
let Some((label, offset)) = tree.find_object_at_or_below(self.pdf, page_idx)? else {
return Ok(None);
};
label.try_dereference()?;
if !label.try_is_dictionary()? {
return Ok(None);
}
let start = label
.try_get_key(b"/St")?
.try_as_integer()?
.unwrap_or(1)
.checked_add(offset)
.ok_or_else(|| Error::Unsupported("page label /St offset overflow".to_string()))?;
let result = ObjectHandle::dictionary(Vec::new());
result.replace_key(b"/S", label.try_get_key(b"/S")?)?;
result.replace_key(b"/P", label.try_get_key(b"/P")?)?;
result.replace_key(b"/St", ObjectHandle::integer(start))?;
Ok(Some(result))
}
#[cfg(test)]
pub fn labels_for_page_range(
&mut self,
start_idx: i64,
end_idx: i64,
new_start_idx: i64,
) -> Result<Vec<(i64, LabelRange)>> {
debug_assert!(
start_idx <= end_idx,
"labels_for_page_range: inverted span (start={start_idx}, end={end_idx})",
);
let mut raw_labels = Vec::new();
self.get_labels_for_page_range(start_idx, end_idx, new_start_idx, &mut raw_labels)?;
raw_labels
.into_iter()
.map(|(index, label)| {
LabelRange::from_handle(&label)?
.map(|label| (index, label))
.ok_or_else(|| {
Error::Unsupported("page label range is not a dictionary".to_string())
}) })
.collect()
}
pub fn labels_for_selection(
&mut self,
src_indices: &[i64],
out_start_idx: i64,
) -> Result<Vec<(i64, LabelRange)>> {
self.labels_for_selection_raw(src_indices, out_start_idx)?
.into_iter()
.map(|(index, label)| {
LabelRange::from_handle(&label)?
.map(|label| (index, label))
.ok_or_else(|| {
Error::Unsupported("page label selection is not a dictionary".to_string())
}) })
.collect()
}
#[cfg(test)]
pub fn labels_for_selection_with_prefix_presence(
&mut self,
src_indices: &[i64],
out_start_idx: i64,
) -> Result<Vec<(i64, LabelRange, bool)>> {
let mut tree = self.pagelabels_tree()?;
let mut out = Vec::with_capacity(src_indices.len());
for (i, &src_idx) in src_indices.iter().enumerate() {
let out_idx = out_start_idx
.checked_add(i64::try_from(i).map_err(|_| {
Error::Unsupported("page label selection index overflow".to_string())
})?) .ok_or_else(|| {
Error::Unsupported("page label output index overflow".to_string())
})?;
let label = match tree.as_mut() {
Some(tree) => self.get_label_for_page_from_tree(tree, src_idx)?,
None => None,
};
let (label, prefix_present) = match label {
Some(label) => {
let prefix_present = label.try_has_key(b"/P")?;
let label = LabelRange::from_handle(&label)?.ok_or_else(|| {
Error::Unsupported("page label range is not a dictionary".to_string())
})?; (label, prefix_present)
}
None => (
LabelRange {
style: LabelStyle::None,
prefix: String::new(),
start: out_idx.checked_add(1).ok_or_else(|| {
Error::Unsupported("page label fabricated start overflow".to_string())
})?,
},
false,
),
};
out.push((out_idx, label, prefix_present));
}
Ok(out)
}
pub(crate) fn labels_for_selection_raw(
&mut self,
src_indices: &[i64],
out_start_idx: i64,
) -> Result<Vec<(i64, ObjectHandle)>> {
let mut tree = self.pagelabels_tree()?;
let mut out = Vec::with_capacity(src_indices.len());
for (i, &src_idx) in src_indices.iter().enumerate() {
let i = i64::try_from(i).map_err(|_| {
Error::Unsupported("page label selection index overflow".to_string())
})?; let out_idx = out_start_idx.checked_add(i).ok_or_else(|| {
Error::Unsupported("page label output index overflow".to_string())
})?;
let label = match tree.as_mut() {
Some(tree) => self.get_label_for_page_from_tree(tree, src_idx)?,
None => None,
}
.unwrap_or_else(|| ObjectHandle::dictionary(Vec::new()));
if !label.try_has_key(b"/St")? {
label.replace_key(
b"/St",
ObjectHandle::integer(out_idx.checked_add(1).ok_or_else(|| {
Error::Unsupported("page label fabricated start overflow".to_string())
})?),
)?; }
out.push((out_idx, label));
}
Ok(out)
}
#[cfg(test)]
pub fn label_prefix_is_present(&mut self, page_idx: i64) -> Result<bool> {
let Some(mut tree) = self.pagelabels_tree()? else {
return Ok(false);
};
let Some(label) = self.get_label_for_page_from_tree(&mut tree, page_idx)? else {
return Ok(false);
};
label.try_has_key(b"/P")
}
pub fn write_reconstructed_labels(&mut self, entries: &[(i64, LabelRange)]) -> Result<()> {
let catalog = self.pdf.root_handle()?;
let mut nums = Vec::with_capacity(entries.len() * 2);
for (idx, range) in entries {
nums.push(ObjectHandle::integer(*idx));
nums.push(Self::reconstructed_label_handle(range, false)?);
}
let page_labels =
ObjectHandle::dictionary(vec![(b"/Nums".to_vec(), ObjectHandle::array(nums))]);
catalog.replace_key(b"/PageLabels", page_labels)?;
Ok(())
}
#[cfg(test)]
pub fn write_reconstructed_labels_with_prefix_presence(
&mut self,
entries: &[(i64, LabelRange, bool)],
) -> Result<()> {
let catalog = self.pdf.root_handle()?;
let mut nums = Vec::with_capacity(entries.len() * 2);
for (idx, range, prefix_present) in entries {
nums.push(ObjectHandle::integer(*idx));
nums.push(Self::reconstructed_label_handle(range, *prefix_present)?);
}
let page_labels =
ObjectHandle::dictionary(vec![(b"/Nums".to_vec(), ObjectHandle::array(nums))]);
catalog.replace_key(b"/PageLabels", page_labels)?;
Ok(())
}
pub(crate) fn write_reconstructed_labels_raw(
&mut self,
entries: &[(i64, ObjectHandle)],
) -> Result<()> {
let catalog = self.pdf.root_handle()?;
let mut nums = Vec::with_capacity(entries.len() * 2);
for (index, label) in entries {
nums.push(ObjectHandle::integer(*index));
nums.push(label.clone());
}
let page_labels =
ObjectHandle::dictionary(vec![(b"/Nums".to_vec(), ObjectHandle::array(nums))]);
catalog.replace_key(b"/PageLabels", page_labels)?;
Ok(())
}
}
impl<R: Read + Seek> Pdf<R> {
pub fn page_labels(&mut self) -> PageLabelDocumentHelper<'_, R> {
PageLabelDocumentHelper::new(self)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::json::Json;
use crate::ObjectRef;
use std::io::Cursor;
#[test]
fn label_range_propagates_an_unresolved_handle_error() {
let handle = ObjectHandle::new_indirect_unresolved(ObjectRef::new(99, 0), -1);
let error = LabelRange::from_handle(&handle).unwrap_err();
assert!(matches!(
error,
Error::Internal(ref message) if message == "object 99 0 belongs to a dropped PDF"
));
}
#[test]
fn non_string_prefix_decodes_to_empty_without_a_type_warning() {
for prefix in [
ObjectHandle::integer(42),
ObjectHandle::name(b"Foo".to_vec()),
ObjectHandle::array(vec![ObjectHandle::integer(1)]),
] {
let label = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::name(b"D".to_vec())),
(b"/P".to_vec(), prefix),
]);
let range = LabelRange::from_handle(&label)
.expect("a non-string prefix must not raise a type warning")
.expect("the label is a dictionary");
assert_eq!(range.prefix, "");
}
}
fn bare_one_page_pdf() -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.7\n");
let off1 = bytes.len() as u64;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = bytes.len() as u64;
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = bytes.len() as u64;
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref = bytes.len() as u64;
bytes.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \ntrailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
Pdf::open(Cursor::new(bytes)).expect("open")
}
fn direct_root_one_page_pdf() -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.4\n");
let off1 = bytes.len() as u64;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Pages /Count 1 /Kids [2 0 R] >>\nendobj\n");
let off2 = bytes.len() as u64;
bytes.extend_from_slice(
b"2 0 obj\n<< /Type /Page /Parent 1 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref = bytes.len() as u64;
bytes.extend_from_slice(
format!(
"xref\n0 3\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \ntrailer\n<< /Size 3 /Root << /Type /Catalog /Pages 1 0 R >> >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
Pdf::open(Cursor::new(bytes)).expect("open direct-root fixture")
}
fn install_page_labels(pdf: &mut Pdf<Cursor<Vec<u8>>>, value: ObjectHandle) {
let catalog_ref = pdf.root_ref().expect("one-page fixture has a catalog root");
let catalog = pdf.get_object_handle(catalog_ref);
catalog.try_is_scalar().expect("resolve catalog");
catalog
.replace_key(b"/PageLabels", value)
.expect("install catalog page labels");
}
fn pdf_with_pagelabels(nums: Vec<ObjectHandle>) -> Pdf<Cursor<Vec<u8>>> {
let mut pdf = bare_one_page_pdf();
let leaf = ObjectHandle::dictionary(vec![(b"/Nums".to_vec(), ObjectHandle::array(nums))]);
let leaf = pdf
.make_indirect_from_object_handle(leaf)
.expect("promote page-label leaf");
install_page_labels(&mut pdf, leaf);
pdf
}
fn pdf_with_catalog_pagelabels(value: ObjectHandle) -> Pdf<Cursor<Vec<u8>>> {
let mut pdf = bare_one_page_pdf();
install_page_labels(&mut pdf, value);
pdf
}
fn label_dict(style: &str, st: Option<i64>, prefix: Option<&str>) -> ObjectHandle {
let mut entries = vec![(
b"/S".to_vec(),
ObjectHandle::name(style.as_bytes().to_vec()),
)];
if let Some(s) = st {
entries.push((b"/St".to_vec(), ObjectHandle::integer(s)));
}
if let Some(p) = prefix {
entries.push((b"/P".to_vec(), ObjectHandle::string(p.as_bytes().to_vec())));
}
ObjectHandle::dictionary(entries)
}
#[test]
fn ranges_reads_a_valid_indirect_tree() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(1), None),
]);
let ranges = pdf.page_labels().ranges().expect("read ranges");
assert_eq!(ranges.len(), 1);
}
#[test]
fn label_for_page_offsets_start() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(10), None),
]);
let mut h = pdf.page_labels();
let lab = h.label_for_page(2).unwrap().expect("range applies");
assert_eq!(lab.start, 12, "/St 10 + offset 2");
assert_eq!(lab.style, LabelStyle::Decimal);
}
#[test]
fn get_label_for_page_preserves_qpdf_raw_dictionary_keys() {
let unknown_with_empty_prefix = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::name(b"Z".to_vec())),
(b"/P".to_vec(), ObjectHandle::string(Vec::new())),
(b"/St".to_vec(), ObjectHandle::integer(3)),
]);
let decimal_without_prefix =
ObjectHandle::dictionary(vec![(b"/S".to_vec(), ObjectHandle::name(b"D".to_vec()))]);
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
unknown_with_empty_prefix,
ObjectHandle::integer(2),
decimal_without_prefix,
]);
let mut h = pdf.page_labels();
let unknown = h
.get_label_for_page(1)
.unwrap()
.expect("unknown style range applies");
assert_eq!(
unknown.try_get_key(b"/S").unwrap().try_as_name().unwrap(),
Some(b"Z".to_vec())
);
assert!(unknown.try_has_key(b"/P").unwrap(), "empty /P is present");
assert_eq!(
unknown.try_get_key(b"/P").unwrap().as_string(),
Some(vec![])
);
assert_eq!(unknown.try_get_key(b"/St").unwrap().as_integer(), Some(4));
let decimal = h
.get_label_for_page(2)
.unwrap()
.expect("decimal range applies");
assert_eq!(
decimal.try_get_key(b"/S").unwrap().try_as_name().unwrap(),
Some(b"D".to_vec())
);
assert!(
!decimal.try_has_key(b"/P").unwrap(),
"absent /P stays absent"
);
assert_eq!(decimal.try_get_key(b"/St").unwrap().as_integer(), Some(1));
}
#[test]
fn get_label_for_page_preserves_indirect_member_identity() {
let mut pdf = bare_one_page_pdf();
let label = pdf
.make_indirect_from_object_handle(label_dict("D", None, Some("prefix")))
.expect("promote label dictionary");
let leaf = ObjectHandle::dictionary(vec![(
b"/Nums".to_vec(),
ObjectHandle::array(vec![ObjectHandle::integer(0), label.clone()]),
)]);
let leaf = pdf
.make_indirect_from_object_handle(leaf)
.expect("promote page-label leaf");
install_page_labels(&mut pdf, leaf);
let source = label.clone();
source.try_is_scalar().unwrap();
let source_style = source.try_get_key(b"/S").unwrap();
let source_prefix = source.try_get_key(b"/P").unwrap();
let mut helper = pdf.page_labels();
let result = helper
.get_label_for_page(0)
.unwrap()
.expect("label dictionary");
assert!(result
.try_get_key(b"/S")
.unwrap()
.is_same_object_as(&source_style));
assert!(result
.try_get_key(b"/P")
.unwrap()
.is_same_object_as(&source_prefix));
}
#[test]
fn page_label_dict_matches_qpdf_factory_shape() {
let label = PageLabelDocumentHelper::<Cursor<Vec<u8>>>::page_label_dict(
LabelStyle::AlphaUpper,
3,
"§",
);
assert_eq!(
label.try_get_key(b"/S").unwrap().try_as_name().unwrap(),
Some(b"A".to_vec())
);
assert_eq!(
label.try_get_key(b"/P").unwrap().as_string(),
Some(vec![0xa7])
);
assert_eq!(label.try_get_key(b"/St").unwrap().as_integer(), Some(3));
let ascii_prefix = PageLabelDocumentHelper::<Cursor<Vec<u8>>>::page_label_dict(
LabelStyle::Decimal,
1,
"A-",
);
assert_eq!(
ascii_prefix.try_get_key(b"/P").unwrap().as_string(),
Some(b"A-".to_vec())
);
let default =
PageLabelDocumentHelper::<Cursor<Vec<u8>>>::page_label_dict(LabelStyle::None, 1, "");
assert!(!default.try_has_key(b"/S").unwrap());
assert!(!default.try_has_key(b"/P").unwrap());
assert!(!default.try_has_key(b"/St").unwrap());
}
#[test]
fn get_labels_for_page_range_accumulates_effective_raw_entries() {
let empty_prefix = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::name(b"D".to_vec())),
(b"/P".to_vec(), ObjectHandle::string(Vec::new())),
]);
let decimal = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::name(b"D".to_vec())),
(b"/St".to_vec(), ObjectHandle::integer(10)),
]);
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("r", None, None),
ObjectHandle::integer(2),
empty_prefix,
ObjectHandle::integer(4),
decimal,
]);
let mut h = pdf.page_labels();
let mut labels = Vec::new();
h.get_labels_for_page_range(1, 4, 0, &mut labels).unwrap();
assert_eq!(labels.len(), 3);
assert_eq!(labels[0].0, 0);
assert_eq!(
labels[0]
.1
.try_get_key(b"/S")
.unwrap()
.try_as_name()
.unwrap(),
Some(b"r".to_vec())
);
assert_eq!(
labels[0].1.try_get_key(b"/St").unwrap().as_integer(),
Some(2)
);
assert_eq!(labels[1].0, 1);
assert!(labels[1].1.try_has_key(b"/P").unwrap());
assert_eq!(
labels[1].1.try_get_key(b"/St").unwrap().as_integer(),
Some(1)
);
assert_eq!(labels[2].0, 3);
assert_eq!(
labels[2].1.try_get_key(b"/St").unwrap().as_integer(),
Some(10)
);
}
#[test]
fn get_labels_for_page_range_skips_redundant_accumulated_leading_entry() {
let mut pdf =
pdf_with_pagelabels(vec![ObjectHandle::integer(0), label_dict("D", None, None)]);
let mut h = pdf.page_labels();
let prior =
PageLabelDocumentHelper::<Cursor<Vec<u8>>>::page_label_dict(LabelStyle::Decimal, 1, "");
prior.replace_key(b"/St", ObjectHandle::integer(1)).unwrap();
let mut labels = vec![(0, prior)];
h.get_labels_for_page_range(1, 1, 1, &mut labels).unwrap();
assert_eq!(labels.len(), 1, "the leading continuation is redundant");
}
#[test]
fn get_labels_for_page_range_handles_missing_tree_and_non_dictionary_prior() {
let mut pdf = bare_one_page_pdf();
let mut h = pdf.page_labels();
let mut labels = vec![(0, ObjectHandle::integer(0))];
h.get_labels_for_page_range(0, 0, 0, &mut labels).unwrap();
assert_eq!(labels.len(), 2);
assert_eq!(labels[1].0, 0);
assert_eq!(
labels[1].1.try_get_key(b"/St").unwrap().as_integer(),
Some(1)
);
}
#[test]
fn get_labels_for_page_range_rejects_fabricated_start_overflow() {
let mut pdf = bare_one_page_pdf();
let error = pdf
.page_labels()
.get_labels_for_page_range(i64::MAX, i64::MAX, i64::MAX, &mut Vec::new())
.expect_err("fabricated /St must use checked arithmetic");
assert!(error.to_string().contains("fabricated start overflow"));
}
#[test]
fn get_labels_for_page_range_skips_non_dictionary_explicit_entries() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", None, None),
ObjectHandle::integer(1),
ObjectHandle::integer(99),
]);
let mut h = pdf.page_labels();
let mut labels = Vec::new();
h.get_labels_for_page_range(0, 2, 0, &mut labels).unwrap();
assert_eq!(
labels.len(),
1,
"a non-dictionary explicit value is skipped"
);
assert_eq!(labels[0].0, 0);
}
#[test]
fn get_labels_for_page_range_rejects_output_index_overflow() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(1), None),
ObjectHandle::integer(1),
label_dict("R", Some(1), None),
]);
let error = pdf
.page_labels()
.get_labels_for_page_range(0, 2, i64::MAX, &mut Vec::new())
.expect_err("reconstructed output index must use checked arithmetic");
assert!(error.to_string().contains("output index overflow"));
}
#[test]
fn labels_for_selection_reconstructs_effective_and_default_ranges() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(5),
label_dict("R", Some(2), Some("P-")),
]);
let mut h = pdf.page_labels();
let labels = h.labels_for_selection(&[0, 5, 6], 10).unwrap();
assert_eq!(labels[0], (10, none_range(11)));
assert_eq!(
labels[1],
(
11,
LabelRange {
style: LabelStyle::RomanUpper,
prefix: "P-".into(),
start: 2,
}
)
);
assert_eq!(
labels[2],
(
12,
LabelRange {
style: LabelStyle::RomanUpper,
prefix: "P-".into(),
start: 3,
}
)
);
}
#[test]
fn labels_for_selection_with_prefix_presence_preserves_raw_prefix_presence() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(1), Some("")),
ObjectHandle::integer(1),
label_dict("D", Some(1), None),
]);
let labels = pdf
.page_labels()
.labels_for_selection_with_prefix_presence(&[0, 1], 0)
.expect("selection labels with prefix presence");
assert_eq!(
labels,
vec![
(
0,
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
},
true,
),
(
1,
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
},
false,
),
]
);
}
#[test]
fn labels_for_selection_handles_missing_tree() {
let mut pdf = bare_one_page_pdf();
let labels = pdf.page_labels().labels_for_selection(&[0], 0).unwrap();
assert_eq!(labels, vec![(0, none_range(1))]);
let raw = pdf.page_labels().labels_for_selection_raw(&[0], 0).unwrap();
assert_eq!(raw[0].1.try_get_key(b"/St").unwrap().as_integer(), Some(1));
}
#[test]
fn labels_for_selection_rejects_output_index_overflow() {
let mut pdf =
pdf_with_pagelabels(vec![ObjectHandle::integer(0), label_dict("D", None, None)]);
let error = pdf
.page_labels()
.labels_for_selection(&[0, 1], i64::MAX)
.expect_err("selection output index must use checked arithmetic");
assert!(error.to_string().contains("output index overflow"));
let error = pdf
.page_labels()
.labels_for_selection_raw(&[0, 1], i64::MAX)
.expect_err("raw selection output index must use checked arithmetic");
assert!(error
.to_string()
.contains("page label output index overflow"));
}
#[test]
fn labels_for_selection_rejects_fabricated_start_overflow() {
let mut pdf = bare_one_page_pdf();
let error = pdf
.page_labels()
.labels_for_selection(&[0], i64::MAX)
.expect_err("fabricated selection /St must use checked arithmetic");
assert!(error.to_string().contains("fabricated start overflow"));
let error = pdf
.page_labels()
.labels_for_selection_raw(&[0], i64::MAX)
.expect_err("raw fabricated selection /St must use checked arithmetic");
assert!(error.to_string().contains("fabricated start overflow"));
}
#[test]
fn raw_label_merges_compare_qpdf_values_and_keep_nonredundant_entries() {
let label = |prefix: ObjectHandle, start| {
ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::name(b"D".to_vec())),
(b"/P".to_vec(), prefix),
(b"/St".to_vec(), ObjectHandle::integer(start)),
])
};
let ranges = vec![
(0, label(ObjectHandle::integer(42), 1)),
(1, label(ObjectHandle::integer(42), 2)),
(2, label(ObjectHandle::name(b"Foo".to_vec()), 3)),
];
let merged = merge_adjacent_raw_labels(ranges).expect("raw merge");
assert_eq!(merged.len(), 2);
let kept = merge_adjacent_raw_labels(vec![
(0, label(ObjectHandle::integer(42), 1)),
(1, ObjectHandle::dictionary(Vec::new())),
])
.expect("raw merge must keep a label without /St");
assert_eq!(kept.len(), 2);
let ranges = vec![
RawPageLabelEntry {
index: 0,
source_id: 1,
source_is_primary: true,
label: label(ObjectHandle::integer(42), 1),
},
RawPageLabelEntry {
index: 1,
source_id: 1,
source_is_primary: true,
label: label(ObjectHandle::integer(42), 2),
},
];
assert_eq!(
merge_adjacent_raw_page_labels(ranges)
.expect("raw foreign merge")
.len(),
1
);
}
#[test]
fn get_label_for_page_rejects_checked_start_overflow() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(i64::MAX), None),
]);
let error = pdf
.page_labels()
.get_label_for_page(1)
.expect_err("/St offset must use checked arithmetic");
assert!(error.to_string().contains("offset overflow"));
}
#[test]
fn get_label_for_page_reports_qpdf_short_number_tree_error() {
let mut pdf = pdf_with_pagelabels(vec![ObjectHandle::integer(0)]);
let error = pdf
.page_labels()
.get_label_for_page(0)
.expect_err("qpdf rejects a short /Nums pair during find");
assert!(error.to_string().contains("items array is too short"));
assert!(pdf
.repair_diagnostics()
.entries()
.iter()
.any(|warning| warning
.message_string()
.contains("update ivalue: items array is too short")));
}
#[test]
fn get_label_for_page_ignores_non_dictionary_values() {
let mut pdf =
pdf_with_pagelabels(vec![ObjectHandle::integer(0), ObjectHandle::integer(99)]);
assert!(pdf.page_labels().get_label_for_page(0).unwrap().is_none());
}
#[test]
fn no_pagelabels_defaults_to_decimal() {
let mut pdf = pdf_with_pagelabels(vec![]); let mut h = pdf.page_labels();
assert!(h.ranges().unwrap().is_empty());
assert!(h.label_for_page(0).unwrap().is_none());
}
#[test]
fn direct_null_page_labels_key_is_absent() {
let mut pdf = pdf_with_catalog_pagelabels(ObjectHandle::null());
let mut helper = pdf.page_labels();
assert!(!helper.has_page_labels().unwrap());
assert!(helper.get_label_for_page(0).unwrap().is_none());
assert!(helper.ranges().unwrap().is_empty());
}
#[test]
fn indirect_null_page_labels_key_is_absent() {
let mut pdf = bare_one_page_pdf();
let null_handle = pdf
.make_indirect_from_object_handle(ObjectHandle::null())
.expect("promote null page-label value");
install_page_labels(&mut pdf, null_handle);
let mut helper = pdf.page_labels();
assert!(!helper.has_page_labels().unwrap());
assert!(helper.get_label_for_page(0).unwrap().is_none());
assert!(helper.ranges().unwrap().is_empty());
}
#[test]
fn page_before_first_range_has_no_effective_label() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(3),
label_dict("R", Some(1), None),
]);
let mut h = pdf.page_labels();
assert!(h.get_label_for_page(0).unwrap().is_none());
assert!(h.get_label_for_page(3).unwrap().is_some());
}
#[test]
fn labels_for_page_range_renumbers_and_copies_explicit() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("r", Some(1), None),
ObjectHandle::integer(5),
label_dict("D", Some(1), None),
]);
let mut h = pdf.page_labels();
let out = h.labels_for_page_range(3, 6, 0).unwrap();
assert_eq!(out[0].0, 0);
assert_eq!(out[0].1.style, LabelStyle::RomanLower);
assert_eq!(out[0].1.start, 4);
assert!(out
.iter()
.any(|(idx, r)| *idx == 2 && r.style == LabelStyle::Decimal));
}
#[test]
fn ranges_resolves_indirect_inner_st() {
let mut pdf = bare_one_page_pdf();
let st = pdf
.make_indirect_from_object_handle(ObjectHandle::integer(7))
.expect("promote /St value");
let label = label_dict("D", None, None);
label.replace_key(b"/St", st).unwrap();
let leaf = ObjectHandle::dictionary(vec![(
b"/Nums".to_vec(),
ObjectHandle::array(vec![ObjectHandle::integer(0), label]),
)]);
let leaf = pdf
.make_indirect_from_object_handle(leaf)
.expect("promote page-label leaf");
install_page_labels(&mut pdf, leaf);
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1);
assert_eq!(ranges[0].1.start, 7, "indirect /St must be resolved");
}
#[test]
fn label_style_name_round_trip_all_variants() {
for (bytes, style, name) in [
(b"D".as_ref(), LabelStyle::Decimal, Some("D")),
(b"R".as_ref(), LabelStyle::RomanUpper, Some("R")),
(b"r".as_ref(), LabelStyle::RomanLower, Some("r")),
(b"A".as_ref(), LabelStyle::AlphaUpper, Some("A")),
(b"a".as_ref(), LabelStyle::AlphaLower, Some("a")),
] {
assert_eq!(LabelStyle::from_name(bytes), style);
assert_eq!(style.to_name(), name);
}
assert_eq!(LabelStyle::from_name(b"Z"), LabelStyle::None);
assert_eq!(LabelStyle::None.to_name(), None);
}
#[test]
fn ranges_handles_indirect_and_non_dict_values() {
let mut pdf = bare_one_page_pdf();
let lab = pdf
.make_indirect_from_object_handle(label_dict("D", None, None))
.expect("promote indirect label dictionary");
let leaf = ObjectHandle::dictionary(vec![(
b"/Nums".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::integer(0),
lab, ObjectHandle::integer(5),
ObjectHandle::integer(99), ]),
)]);
let leaf = pdf
.make_indirect_from_object_handle(leaf)
.expect("promote page-label leaf");
install_page_labels(&mut pdf, leaf);
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1, "non-dict value skipped");
assert_eq!(ranges[0].0, 0);
assert_eq!(ranges[0].1.style, LabelStyle::Decimal);
}
#[test]
fn ranges_non_name_style_resolves_to_none() {
let mut pdf = bare_one_page_pdf();
let lab = ObjectHandle::dictionary(vec![
(b"/S".to_vec(), ObjectHandle::integer(0)), ]);
let leaf = ObjectHandle::dictionary(vec![(
b"/Nums".to_vec(),
ObjectHandle::array(vec![ObjectHandle::integer(0), lab]),
)]);
let leaf = pdf
.make_indirect_from_object_handle(leaf)
.expect("promote page-label leaf");
install_page_labels(&mut pdf, leaf);
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1);
assert_eq!(ranges[0].1.style, LabelStyle::None);
}
#[test]
fn labels_for_page_range_fabricates_default_when_first_unlabeled() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(5),
label_dict("D", Some(1), None),
]);
let mut h = pdf.page_labels();
let out = h.labels_for_page_range(0, 6, 0).unwrap();
assert_eq!(out[0].0, 0);
assert_eq!(out[0].1.style, LabelStyle::None);
assert_eq!(out[0].1.start, 1);
assert!(out.iter().any(|(idx, _)| *idx == 5));
}
#[test]
fn labels_for_page_range_single_page_span_does_not_panic() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(1), None),
]);
let mut h = pdf.page_labels();
let out = h.labels_for_page_range(4, 4, 0).unwrap();
assert_eq!(out, vec![(0, dec(5))], "St 1 + offset 4 = 5");
}
#[test]
fn helper_rejects_non_dict_catalog() {
let mut pdf = pdf_with_pagelabels(vec![]);
let catalog_ref = pdf.root_ref().unwrap();
pdf.replace_object(catalog_ref, ObjectHandle::integer(0))
.unwrap(); let mut h = pdf.page_labels();
let error = h
.has_page_labels()
.expect_err("qpdf getRoot rejects a non-dictionary Catalog");
assert_eq!(error.to_string(), "unable to find /Root dictionary");
}
#[test]
fn helper_rejects_missing_root() {
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.7\n");
let off1 = bytes.len() as u64;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let xref = bytes.len() as u64;
bytes.extend_from_slice(
format!(
"xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \ntrailer\n<< /Size 2 >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("rootless trailer still opens");
assert!(pdf.root_ref().is_none(), "rootless trailer => no root_ref");
let mut h = pdf.page_labels();
let error = h
.has_page_labels()
.expect_err("qpdf getRoot rejects a missing Catalog");
assert_eq!(error.to_string(), "unable to find /Root dictionary");
}
fn dec(start: i64) -> LabelRange {
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start,
}
}
fn none_range(start: i64) -> LabelRange {
LabelRange {
style: LabelStyle::None,
prefix: String::new(),
start,
}
}
#[test]
fn write_reconstructed_labels_installs_direct_nums_dict() {
let mut pdf = bare_one_page_pdf();
{
let mut h = pdf.page_labels();
h.write_reconstructed_labels(&[
(0, none_range(1)),
(
3,
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
},
),
])
.unwrap();
}
let catalog_ref = pdf.root_ref().unwrap();
let catalog = pdf.get_object_handle(catalog_ref);
catalog.try_is_scalar().unwrap();
let page_labels = catalog.try_get_key(b"/PageLabels").unwrap();
assert!(page_labels.as_dictionary().is_some());
assert!(!page_labels.is_indirect(), "/PageLabels must be direct");
let nums = page_labels.try_get_key(b"/Nums").unwrap();
let nums = nums.as_array().expect("/Nums must be a direct array");
assert_eq!(nums.len(), 4, "2 entries * (index, dict)");
assert_eq!(nums[0].as_integer(), Some(0));
assert_eq!(nums[1].try_get_key(b"/St").unwrap().as_integer(), Some(1));
assert!(!nums[1].try_has_key(b"/S").unwrap());
assert_eq!(nums[2].as_integer(), Some(3));
assert_eq!(
nums[3].try_get_key(b"/S").unwrap().try_as_name().unwrap(),
Some(b"D".to_vec())
);
assert_eq!(nums[3].try_get_key(b"/St").unwrap().as_integer(), Some(1));
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 2);
assert_eq!(ranges[0].0, 0);
assert_eq!(ranges[1].0, 3);
}
#[test]
fn direct_catalog_root_supports_page_label_reconstruction_and_readback() {
let mut pdf = direct_root_one_page_pdf();
pdf.page_labels()
.write_reconstructed_labels(&[(0, dec(1))])
.expect("direct Catalog must accept reconstructed labels");
let mut helper = pdf.page_labels();
assert!(helper
.has_page_labels()
.expect("read direct Catalog labels"));
assert_eq!(
helper.ranges().expect("read reconstructed labels"),
vec![(0, dec(1))]
);
}
#[test]
fn direct_catalog_root_supports_raw_page_label_reconstruction() {
let mut pdf = direct_root_one_page_pdf();
pdf.page_labels()
.write_reconstructed_labels_raw(&[(0, label_dict("A", Some(1), None))])
.expect("direct Catalog must accept raw reconstructed labels");
let root = pdf.root_handle().expect("direct Catalog root");
let page_labels = root.try_get_key(b"/PageLabels").expect("PageLabels key");
assert_eq!(
page_labels
.try_get_key(b"/Nums")
.expect("Nums key")
.try_array_len()
.expect("Nums array"),
Some(2)
);
}
#[test]
fn write_reconstructed_labels_preserves_catalog_source_metadata() {
let mut pdf = bare_one_page_pdf();
let catalog_ref = pdf.root_ref().expect("catalog ref");
let catalog = pdf.get_object_handle(catalog_ref);
catalog.try_dereference().expect("resolve catalog");
let source_description = catalog.description();
let source_end_offsets = catalog.end_offsets();
assert!(
source_end_offsets.0 >= 0 && source_end_offsets.1 >= 0,
"fixture must establish catalog source extents"
);
pdf.page_labels()
.write_reconstructed_labels(&[(0, none_range(1))])
.expect("canonical label write");
assert_eq!(
catalog.description(),
source_description,
"replaceKey must preserve the catalog object description"
);
assert_eq!(
catalog.end_offsets(),
source_end_offsets,
"replaceKey must preserve the catalog source extents"
);
assert!(
catalog
.try_get_key(b"/PageLabels")
.expect("PageLabels key")
.try_as_dictionary()
.expect("PageLabels dictionary")
.is_some(),
"the live catalog handle must observe the replacement"
);
}
#[test]
fn label_prefix_presence_distinguishes_empty_and_absent_prefixes() {
let mut explicit_empty = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(1), Some("")),
]);
let mut helper = explicit_empty.page_labels();
assert!(helper.label_prefix_is_present(0).unwrap());
let mut empty_tree = pdf_with_pagelabels(vec![]);
assert!(!empty_tree.page_labels().label_prefix_is_present(0).unwrap());
let mut absent = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("D", Some(1), None),
]);
assert!(!absent.page_labels().label_prefix_is_present(0).unwrap());
let mut no_tree = bare_one_page_pdf();
assert!(!no_tree.page_labels().label_prefix_is_present(0).unwrap());
}
#[test]
fn reconstructed_labels_can_retain_an_explicit_empty_prefix() {
let mut pdf = bare_one_page_pdf();
let range = LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
};
pdf.page_labels()
.write_reconstructed_labels_with_prefix_presence(&[
(0, range.clone(), true),
(2, range, false),
])
.unwrap();
let catalog_ref = pdf.root_ref().unwrap();
let catalog = pdf.get_object_handle(catalog_ref);
catalog.try_is_scalar().unwrap();
let page_labels = catalog.try_get_key(b"/PageLabels").unwrap();
let nums = page_labels
.try_get_key(b"/Nums")
.unwrap()
.as_array()
.expect("PageLabels /Nums must be an array");
assert_eq!(
nums[1].try_get_key(b"/P").unwrap().as_string(),
Some(Vec::new())
);
assert!(!nums[3].try_has_key(b"/P").unwrap());
}
#[test]
fn write_reconstructed_labels_replaces_existing_indirect_tree() {
let mut pdf = pdf_with_pagelabels(vec![
ObjectHandle::integer(0),
label_dict("R", Some(1), None),
]);
{
let mut h = pdf.page_labels();
h.write_reconstructed_labels(&[(0, none_range(1))]).unwrap();
}
let catalog_ref = pdf.root_ref().unwrap();
let catalog = pdf.get_object_handle(catalog_ref);
catalog.try_is_scalar().unwrap();
let page_labels = catalog.try_get_key(b"/PageLabels").unwrap();
assert!(
page_labels.as_dictionary().is_some() && !page_labels.is_indirect(),
"/PageLabels must now be a direct dict, not the old indirect ref"
);
}
#[test]
fn write_reconstructed_labels_rejects_missing_root() {
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.7\n");
let off1 = bytes.len() as u64;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let xref = bytes.len() as u64;
bytes.extend_from_slice(
format!(
"xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \ntrailer\n<< /Size 2 >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("rootless trailer still opens");
let mut h = pdf.page_labels();
let error = h
.write_reconstructed_labels(&[(0, none_range(1))])
.expect_err("qpdf getRoot rejects a missing Catalog");
assert_eq!(error.to_string(), "unable to find /Root dictionary");
}
#[test]
fn write_reconstructed_labels_rejects_non_dict_catalog() {
let mut pdf = bare_one_page_pdf();
let catalog_ref = pdf.root_ref().unwrap();
pdf.replace_object(catalog_ref, ObjectHandle::integer(0))
.unwrap(); let mut h = pdf.page_labels();
let error = h
.write_reconstructed_labels(&[(0, none_range(1))])
.expect_err("qpdf getRoot rejects a non-dictionary Catalog");
assert_eq!(error.to_string(), "unable to find /Root dictionary");
}
use std::path::{Path, PathBuf};
use std::process::Command;
fn pinned_qpdf() -> Option<PathBuf> {
#[cfg(target_os = "linux")]
let candidates: &[&str] = &["/usr/bin/qpdf", "qpdf"];
#[cfg(not(target_os = "linux"))]
let candidates: &[&str] = &["qpdf"];
for candidate in candidates {
let Ok(version) = Command::new(candidate).arg("--version").output() else {
continue;
};
if !version.status.success() {
continue;
}
let first_line = String::from_utf8_lossy(&version.stdout)
.lines()
.next()
.unwrap_or_default()
.to_string();
if first_line == "qpdf version 11.9.0" {
return Some(PathBuf::from(candidate));
} }
None }
fn qpdf_pagelabels_probe_pdf() -> Vec<u8> {
let npages = 7u32;
let mut bodies: Vec<Vec<u8>> =
vec![b"<< /Type /Catalog /Pages 2 0 R /PageLabels 10 0 R >>".to_vec()];
let kids = (0..npages)
.map(|i| format!("{} 0 R", 3 + i))
.collect::<Vec<_>>()
.join(" ");
bodies.push(format!("<< /Type /Pages /Kids [{kids}] /Count {npages} >>").into_bytes());
for _ in 0..npages {
bodies.push(b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>".to_vec());
}
bodies.push(
b"<< /Nums [\
0 << /S /r >> \
1 << >> \
2 << /St 9 >> \
3 << /P (Ch-) >> \
4 << /S /Z >> \
5 << /S /D /P () /St 2 >> \
] >>"
.to_vec(),
);
let mut bytes = b"%PDF-1.7\n".to_vec();
let mut offsets = Vec::with_capacity(bodies.len());
for (index, body) in bodies.iter().enumerate() {
offsets.push(bytes.len());
bytes.extend_from_slice(format!("{} 0 obj\n", index + 1).as_bytes());
bytes.extend_from_slice(body);
bytes.extend_from_slice(b"\nendobj\n");
}
let xref_start = bytes.len();
let total = bodies.len() + 1;
bytes.extend_from_slice(format!("xref\n0 {total}\n0000000000 65535 f \n").as_bytes());
for offset in &offsets {
bytes.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
bytes.extend_from_slice(
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
bytes
}
fn qpdf_json_pagelabels(qpdf: &Path, path: &Path) -> Json {
let qpdf = Command::new(qpdf)
.arg("--json=2")
.arg("--json-key=pagelabels")
.arg(path)
.output()
.expect("run pinned qpdf pagelabels oracle");
let qpdf_stderr = String::from_utf8_lossy(&qpdf.stderr);
assert!(
qpdf.status.success(),
"qpdf --json=2 --json-key=pagelabels failed: {qpdf_stderr}"
);
let document = Json::parse(&qpdf.stdout).expect("parse qpdf JSON output");
document.get_dict_item("pagelabels")
}
fn assert_label_matches_qpdf_json(
flpdf_label: &ObjectHandle,
qpdf_label: &Json,
context: &str,
) {
let qpdf_s = qpdf_label.get_dict_item("/S");
if qpdf_s.is_null() {
assert!(
!flpdf_label.try_has_key(b"/S").unwrap(),
"{context}: /S must be absent"
);
} else {
let name = qpdf_s.get_string().expect("qpdf /S is a JSON string");
let expected = name.strip_prefix(b"/").expect("qpdf name starts with /");
assert_eq!(
flpdf_label
.try_get_key(b"/S")
.unwrap()
.try_as_name()
.unwrap()
.as_deref(),
Some(expected),
"{context}: /S mismatch"
);
}
let qpdf_p = qpdf_label.get_dict_item("/P");
if qpdf_p.is_null() {
assert!(
!flpdf_label.try_has_key(b"/P").unwrap(),
"{context}: /P must be absent"
);
} else {
let string = qpdf_p.get_string().expect("qpdf /P is a JSON string");
let expected = string
.strip_prefix(b"u:")
.expect("fixture /P values are ASCII (qpdf u: prefix)");
assert_eq!(
flpdf_label
.try_get_key(b"/P")
.unwrap()
.as_string()
.as_deref(),
Some(expected),
"{context}: /P mismatch"
);
}
let qpdf_st = qpdf_label
.get_dict_item("/St")
.get_number()
.expect("qpdf /St is always present");
let qpdf_st: i64 = std::str::from_utf8(&qpdf_st)
.unwrap()
.parse()
.expect("qpdf /St is an integer");
assert_eq!(
flpdf_label.try_get_key(b"/St").unwrap().as_integer(),
Some(qpdf_st),
"{context}: /St mismatch"
);
}
#[test]
fn get_labels_for_page_range_matches_pinned_qpdf_json_oracle() {
let Some(qpdf) = pinned_qpdf() else {
eprintln!("pinned qpdf 11.9.0 unavailable; skipping pagelabels oracle");
return;
};
let bytes = qpdf_pagelabels_probe_pdf();
let directory = tempfile::tempdir().expect("temporary qpdf oracle directory");
let path = directory.path().join("pagelabels-probe.pdf");
std::fs::write(&path, &bytes).expect("write qpdf oracle fixture");
let pagelabels = qpdf_json_pagelabels(&qpdf, &path);
let mut expected: Vec<(i64, Json)> = Vec::new();
pagelabels.for_each_array_item(|entry| {
let index = entry
.get_dict_item("index")
.get_number()
.and_then(|bytes| std::str::from_utf8(&bytes).ok()?.parse::<i64>().ok())
.expect("qpdf pagelabels[].index is an integer");
expected.push((index, entry.get_dict_item("label")));
});
assert_eq!(
expected.iter().map(|(index, _)| *index).collect::<Vec<_>>(),
(0..=5).collect::<Vec<_>>(),
"qpdf pagelabels index list"
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("open");
let mut helper = pdf.page_labels();
let mut actual: Vec<(i64, ObjectHandle)> = Vec::new();
helper
.get_labels_for_page_range(0, 6, 0, &mut actual)
.expect("get_labels_for_page_range");
assert_eq!(actual.len(), expected.len(), "entry count");
for ((actual_index, actual_label), (expected_index, expected_label)) in
actual.iter().zip(expected.iter())
{
assert_eq!(actual_index, expected_index, "index");
assert_label_matches_qpdf_json(
actual_label,
expected_label,
&format!("index {actual_index}"),
);
}
}
#[test]
fn get_label_for_page_matches_pinned_qpdf_json_oracle_for_every_page() {
let Some(qpdf) = pinned_qpdf() else {
eprintln!("pinned qpdf 11.9.0 unavailable; skipping pagelabels oracle");
return;
};
let bytes = qpdf_pagelabels_probe_pdf();
let directory = tempfile::tempdir().expect("temporary qpdf oracle directory");
let input_path = directory.path().join("pagelabels-probe.pdf");
std::fs::write(&input_path, &bytes).expect("write qpdf oracle fixture");
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("open");
let mut helper = pdf.page_labels();
for page_idx in 0i64..7 {
let output_path = directory.path().join(format!("page-{page_idx}.pdf"));
let extract = Command::new(&qpdf)
.arg("--empty")
.arg("--pages")
.arg(&input_path)
.arg((page_idx + 1).to_string()) .arg("--")
.arg(&output_path)
.output()
.expect("run pinned qpdf page extraction");
let extract_stderr = String::from_utf8_lossy(&extract.stderr);
assert!(
extract.status.success(),
"qpdf page {page_idx} extraction failed: {extract_stderr}"
);
let entries = qpdf_json_pagelabels(&qpdf, &output_path);
let mut expected_label = None;
entries.for_each_array_item(|entry| {
expected_label = Some(entry.get_dict_item("label"));
});
let expected_label =
expected_label.expect("single-page extraction always has an effective label");
let actual = helper
.get_label_for_page(page_idx)
.expect("get_label_for_page")
.expect("every page in this fixture has an effective label");
assert_label_matches_qpdf_json(&actual, &expected_label, &format!("page {page_idx}"));
}
}
}