use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
use crate::page_form_xobject::{
import_pages_as_form_xobjects, page_to_form_xobject, read_page_transform, transformation_matrix,
};
use crate::page_object_helper::{PageBox, PageObjectHelper};
use crate::page_range::PageRange;
use crate::pages::page_refs;
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result, Stream};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OverlayKind {
Underlay,
Overlay,
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct OverlaySource {
pub kind: OverlayKind,
pub xobject_ref: ObjectRef,
}
fn fmt_number(v: f64) -> String {
let mut s = format!("{v:.5}");
if s.starts_with("-0.00000") {
s = "0.00000".to_string();
}
let trimmed = s.trim_end_matches('0').trim_end_matches('.');
trimmed.to_string()
}
const IDENTITY_MATRIX: [f64; 6] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
fn qpdf_concat(this: [f64; 6], other: [f64; 6]) -> [f64; 6] {
let [a, b, c, d, e, f] = this;
let [oa, ob, oc, od, oe, of] = other;
[
a * oa + c * ob,
b * oa + d * ob,
a * oc + c * od,
b * oc + d * od,
a * oe + c * of + e,
b * oe + d * of + f,
]
}
fn qpdf_scale(this: [f64; 6], sx: f64, sy: f64) -> [f64; 6] {
qpdf_concat(this, [sx, 0.0, 0.0, sy, 0.0, 0.0])
}
fn qpdf_translate(this: [f64; 6], tx: f64, ty: f64) -> [f64; 6] {
qpdf_concat(this, [1.0, 0.0, 0.0, 1.0, tx, ty])
}
fn fix_rounding(d: f64) -> f64 {
if d > -0.00001 && d < 0.00001 {
0.0
} else {
d
}
}
fn matrix_unparse(m: [f64; 6]) -> String {
let parts: Vec<String> = m.iter().map(|&x| fmt_number(fix_rounding(x))).collect();
parts.join(" ")
}
fn matrix_for_form_xobject_placement(
fo_bbox: [f64; 4],
fo_matrix: [f64; 6],
rect: [f64; 4],
tmatrix: [f64; 6],
allow_shrink: bool,
allow_expand: bool,
) -> Option<[f64; 6]> {
let wmatrix = qpdf_concat(qpdf_concat(IDENTITY_MATRIX, tmatrix), fo_matrix);
let t = transform_bbox(fo_bbox, wmatrix);
let [t_llx, t_lly, t_urx, t_ury] = t;
if t_urx == t_llx || t_ury == t_lly {
return None;
}
let [rllx, rlly, rurx, rury] = rect;
let rect_w = rurx - rllx;
let rect_h = rury - rlly;
let t_w = t_urx - t_llx;
let t_h = t_ury - t_lly;
let xscale = rect_w / t_w;
let yscale = rect_h / t_h;
let mut scale = if xscale < yscale { xscale } else { yscale };
if scale > 1.0 {
if !allow_expand {
scale = 1.0;
}
} else if scale < 1.0 && !allow_shrink {
scale = 1.0;
}
let wmatrix = qpdf_concat(
qpdf_concat(qpdf_scale(IDENTITY_MATRIX, scale, scale), tmatrix),
fo_matrix,
);
let t = transform_bbox(fo_bbox, wmatrix);
let [t_llx, t_lly, t_urx, t_ury] = t;
let t_cx = (t_llx + t_urx) / 2.0;
let t_cy = (t_lly + t_ury) / 2.0;
let r_cx = (rllx + rurx) / 2.0;
let r_cy = (rlly + rury) / 2.0;
let tx = r_cx - t_cx;
let ty = r_cy - t_cy;
let cm = qpdf_concat(
qpdf_scale(qpdf_translate(IDENTITY_MATRIX, tx, ty), scale, scale),
tmatrix,
);
Some(cm)
}
fn place_form_xobject(
fo_bbox: [f64; 4],
fo_matrix: [f64; 6],
rect: [f64; 4],
tmatrix: [f64; 6],
allow_shrink: bool,
allow_expand: bool,
name: &str,
) -> String {
let cm = matrix_for_form_xobject_placement(
fo_bbox,
fo_matrix,
rect,
tmatrix,
allow_shrink,
allow_expand,
)
.unwrap_or(IDENTITY_MATRIX);
format!("q\n{} cm\n/{} Do\nQ\n", matrix_unparse(cm), name)
}
pub(crate) fn apply_overlays_to_page<R: Read + Seek>(
dest: &mut Pdf<R>,
dest_page_ref: ObjectRef,
sources: &[OverlaySource],
) -> Result<()> {
let mut underlays: Vec<ObjectRef> = Vec::new();
let mut overlays: Vec<ObjectRef> = Vec::new();
for src in sources {
match src.kind {
OverlayKind::Underlay => underlays.push(src.xobject_ref),
OverlayKind::Overlay => overlays.push(src.xobject_ref),
}
}
let media_box = page_box_or_err(dest, dest_page_ref, BoxKind::Media)?;
let trim_box = page_box_or_err(dest, dest_page_ref, BoxKind::Trim)?;
let dest_transform = read_page_transform(dest, dest_page_ref)?;
let [n_llx, n_lly, n_urx, n_ury] = normalize_rectangle(page_box_array(&trim_box));
let trim_w = n_urx - n_llx;
let trim_h = n_ury - n_lly;
let tmatrix = transformation_matrix(&dest_transform, trim_w, trim_h, true);
let fx0_ref = page_to_form_xobject(dest, dest_page_ref)?;
let mut xobject_dict = Dictionary::new();
xobject_dict.insert("Fx0", Object::Reference(fx0_ref));
let mut next_index = 1u32;
let mut underlay_names: Vec<(String, ObjectRef)> = Vec::new();
let mut overlay_names: Vec<(String, ObjectRef)> = Vec::new();
for xref in &underlays {
let name = format!("Fx{next_index}");
xobject_dict.insert(name.as_bytes(), Object::Reference(*xref));
underlay_names.push((name, *xref));
next_index += 1;
}
for xref in &overlays {
let name = format!("Fx{next_index}");
xobject_dict.insert(name.as_bytes(), Object::Reference(*xref));
overlay_names.push((name, *xref));
next_index += 1;
}
let trim_rect = normalize_rectangle(page_box_array(&trim_box));
let media_rect = normalize_rectangle(page_box_array(&media_box));
let mut content = String::new();
for (name, xref) in &underlay_names {
let (bbox, fmatrix) = fo_bbox_and_matrix(dest, *xref)?;
content.push_str(&place_form_xobject(
bbox, fmatrix, trim_rect, tmatrix, true, false, name,
));
}
{
let (bbox, fmatrix) = fo_bbox_and_matrix(dest, fx0_ref)?;
content.push_str(&place_form_xobject(
bbox, fmatrix, media_rect, tmatrix, false, false, "Fx0",
));
}
for (name, xref) in &overlay_names {
let (bbox, fmatrix) = fo_bbox_and_matrix(dest, *xref)?;
content.push_str(&place_form_xobject(
bbox, fmatrix, trim_rect, tmatrix, true, false, name,
));
}
let contents_ref = next_object_ref(dest)?;
let contents_stream = Stream::new(Dictionary::new(), content.into_bytes());
dest.set_object(contents_ref, Object::Stream(contents_stream));
let mut page_dict = page_dictionary(dest, dest_page_ref)?;
let mut resources = Dictionary::new();
resources.insert("XObject", Object::Dictionary(xobject_dict));
page_dict.insert("Resources", Object::Dictionary(resources));
page_dict.insert("Contents", Object::Reference(contents_ref));
dest.set_object(dest_page_ref, Object::Dictionary(page_dict));
Ok(())
}
fn map_overlay_pages(
from_pages: &[u32],
to_pages: &[u32],
repeat_pages: &[u32],
) -> Vec<(u32, u32)> {
let mut pairs = Vec::new();
for (i, &dest) in to_pages.iter().enumerate() {
let source = if i < from_pages.len() {
from_pages[i]
} else if !repeat_pages.is_empty() {
repeat_pages[(i - from_pages.len()) % repeat_pages.len()]
} else {
continue;
};
pairs.push((dest, source));
}
pairs
}
fn spec_page_sources<RS, RT>(
dest: &mut Pdf<RT>,
source: &mut Pdf<RS>,
kind: OverlayKind,
from: &PageRange,
to: &PageRange,
repeat: Option<&PageRange>,
n_dest: u32,
) -> Result<Vec<(u32, OverlaySource)>>
where
RS: Read + Seek,
RT: Read + Seek,
{
let source_pages = page_refs(source)?;
let n_source = u32_len(source_pages.len());
let pairs = resolve_spec_pairs(n_source, from, to, repeat, n_dest)?;
let mut distinct_sources: Vec<u32> = Vec::new();
let mut seen = BTreeSet::new();
for &(_dest_page, source_page) in &pairs {
if seen.insert(source_page) {
distinct_sources.push(source_page);
}
}
let source_refs: Vec<ObjectRef> = distinct_sources
.iter()
.map(|&p| page_ref_for(&source_pages, p, "source"))
.collect::<Result<_>>()?;
let imported_refs = import_pages_as_form_xobjects(dest, source, &source_refs)?;
let imported: BTreeMap<u32, ObjectRef> = distinct_sources
.iter()
.copied()
.zip(imported_refs)
.collect();
Ok(pairs
.iter()
.map(|&(dest_page, source_page)| {
let xobject_ref = imported[&source_page];
(dest_page, OverlaySource { kind, xobject_ref })
})
.collect())
}
pub(crate) fn resolve_spec_pairs(
n_source: u32,
from: &PageRange,
to: &PageRange,
repeat: Option<&PageRange>,
n_dest: u32,
) -> Result<Vec<(u32, u32)>> {
let from_pages = from.resolve(n_source)?;
let to_pages = to.resolve(n_dest)?;
let repeat_pages = match repeat {
Some(pr) => pr.resolve(n_source)?,
None => Vec::new(),
};
Ok(map_overlay_pages(&from_pages, &to_pages, &repeat_pages))
}
#[allow(dead_code)]
fn apply_overlay_spec<RS, RT>(
dest: &mut Pdf<RT>,
source: &mut Pdf<RS>,
kind: OverlayKind,
from: &PageRange,
to: &PageRange,
repeat: Option<&PageRange>,
) -> Result<()>
where
RS: Read + Seek,
RT: Read + Seek,
{
let n_dest = u32_len(page_refs(dest)?.len());
let sources = spec_page_sources(dest, source, kind, from, to, repeat, n_dest)?;
apply_aggregated_sources(dest, group_sources_by_dest_page(&sources))
}
pub struct OverlaySpec<RS: Read + Seek> {
pub source: Pdf<RS>,
pub kind: OverlayKind,
pub from: PageRange,
pub to: PageRange,
pub repeat: Option<PageRange>,
}
fn group_sources_by_dest_page(
entries: &[(u32, OverlaySource)],
) -> BTreeMap<u32, Vec<OverlaySource>> {
let mut by_page: BTreeMap<u32, Vec<OverlaySource>> = BTreeMap::new();
for &(dest_page, source) in entries {
by_page.entry(dest_page).or_default().push(source);
}
by_page
}
pub(crate) fn kind_stable_partition<T, F>(entries: Vec<T>, kind_of: F) -> Vec<T>
where
F: Fn(&T) -> OverlayKind,
{
let (underlays, overlays): (Vec<T>, Vec<T>) = entries
.into_iter()
.partition(|e| matches!(kind_of(e), OverlayKind::Underlay));
let mut out = underlays;
out.extend(overlays);
out
}
fn apply_aggregated_sources<R: Read + Seek>(
dest: &mut Pdf<R>,
by_page: BTreeMap<u32, Vec<OverlaySource>>,
) -> Result<()> {
let dest_pages = page_refs(dest)?;
for (dest_page, sources) in by_page {
let dest_ref = page_ref_for(&dest_pages, dest_page, "destination")?;
apply_overlays_to_page(dest, dest_ref, &sources)?;
}
Ok(())
}
pub fn apply_overlay_specs<RS, RT>(dest: &mut Pdf<RT>, specs: &mut [OverlaySpec<RS>]) -> Result<()>
where
RS: Read + Seek,
RT: Read + Seek,
{
let n_dest = u32_len(page_refs(dest)?.len());
let mut entries: Vec<(u32, OverlaySource)> = Vec::new();
for spec in specs.iter_mut() {
let sources = spec_page_sources(
dest,
&mut spec.source,
spec.kind,
&spec.from,
&spec.to,
spec.repeat.as_ref(),
n_dest,
)?;
entries.extend(sources);
}
apply_aggregated_sources(dest, group_sources_by_dest_page(&entries))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct OverlayVerboseSource {
pub spec_index: usize,
pub kind: OverlayKind,
pub src_page: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OverlayVerbosePage {
pub dest_page: u32,
pub sources: Vec<OverlayVerboseSource>,
}
pub fn overlay_verbose_report<RS, RT>(
dest: &mut Pdf<RT>,
specs: &mut [OverlaySpec<RS>],
) -> Result<Vec<OverlayVerbosePage>>
where
RS: Read + Seek,
RT: Read + Seek,
{
let n_dest = u32_len(page_refs(dest)?.len());
let mut flat: Vec<(u32, OverlayVerboseSource)> = Vec::new();
for (spec_index, spec) in specs.iter_mut().enumerate() {
let n_source = u32_len(page_refs(&mut spec.source)?.len());
let pairs =
resolve_spec_pairs(n_source, &spec.from, &spec.to, spec.repeat.as_ref(), n_dest)?;
for (dest_page, src_page) in pairs {
flat.push((
dest_page,
OverlayVerboseSource {
spec_index,
kind: spec.kind,
src_page,
},
));
}
}
let mut by_page: BTreeMap<u32, Vec<OverlayVerboseSource>> = BTreeMap::new();
for (dest_page, src) in flat {
by_page.entry(dest_page).or_default().push(src);
}
let mut out = Vec::with_capacity(n_dest as usize);
for dest_page in 1..=n_dest {
let sources = by_page.remove(&dest_page).unwrap_or_default();
let sources = kind_stable_partition(sources, |s| s.kind);
out.push(OverlayVerbosePage { dest_page, sources });
}
Ok(out)
}
fn u32_len(len: usize) -> u32 {
u32::try_from(len).unwrap_or(u32::MAX)
}
fn page_ref_for(pages: &[ObjectRef], page: u32, which: &str) -> Result<ObjectRef> {
let idx = (page as usize)
.checked_sub(1)
.filter(|&i| i < pages.len())
.ok_or_else(|| {
Error::Unsupported(format!(
"{which} page {page} is out of range (document has {} page(s))",
pages.len()
))
})?;
Ok(pages[idx])
}
#[derive(Clone, Copy)]
enum BoxKind {
Media,
Trim,
}
fn page_box_or_err<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
kind: BoxKind,
) -> Result<PageBox> {
let mut helper = PageObjectHelper::new(page_ref, pdf);
let opt = match kind {
BoxKind::Media => helper.media_box()?,
BoxKind::Trim => helper.trim_box()?,
};
opt.ok_or_else(|| {
Error::Unsupported(format!(
"destination page {page_ref} has no usable placement box"
))
})
}
fn page_box_array(b: &PageBox) -> [f64; 4] {
[b.llx, b.lly, b.urx, b.ury]
}
fn normalize_rectangle([x0, x1, x2, x3]: [f64; 4]) -> [f64; 4] {
[x0.min(x2), x1.min(x3), x0.max(x2), x1.max(x3)]
}
fn as_f64(o: &Object) -> f64 {
o.as_integer()
.map(|i| i as f64)
.or_else(|| o.as_real())
.unwrap_or(0.0)
}
fn matrix_or_identity(dict: &Dictionary) -> [f64; 6] {
match dict.get("Matrix").and_then(Object::as_array) {
Some(m) if m.len() >= 6 => [
as_f64(&m[0]),
as_f64(&m[1]),
as_f64(&m[2]),
as_f64(&m[3]),
as_f64(&m[4]),
as_f64(&m[5]),
],
_ => [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
}
}
fn transform_bbox(bbox: [f64; 4], m: [f64; 6]) -> [f64; 4] {
let [llx, lly, urx, ury] = bbox;
let [a, b, c, d, e, f] = m;
let pt = |x: f64, y: f64| (a * x + c * y + e, b * x + d * y + f);
let corners = [pt(llx, lly), pt(urx, lly), pt(urx, ury), pt(llx, ury)];
let mut min_x = corners[0].0;
let mut max_x = corners[0].0;
let mut min_y = corners[0].1;
let mut max_y = corners[0].1;
for &(x, y) in &corners[1..] {
min_x = min_x.min(x);
max_x = max_x.max(x);
min_y = min_y.min(y);
max_y = max_y.max(y);
}
[min_x, min_y, max_x, max_y]
}
fn fo_bbox_and_matrix<R: Read + Seek>(
pdf: &mut Pdf<R>,
xobject_ref: ObjectRef,
) -> Result<([f64; 4], [f64; 6])> {
let obj = pdf.resolve(xobject_ref)?;
let dict = match &obj {
Object::Stream(s) => &s.dict,
Object::Dictionary(d) => d,
_ => {
return Err(Error::Unsupported(format!(
"Form XObject {xobject_ref} is not a stream or dictionary"
)));
}
};
let matrix = matrix_or_identity(dict);
let bbox_entry = dict.get("BBox").ok_or_else(|| {
Error::Unsupported(format!("Form XObject {xobject_ref} has no /BBox array"))
})?;
let resolved_bbox = match bbox_entry {
Object::Reference(r) => pdf.resolve(*r)?,
other => other.clone(),
};
let arr = resolved_bbox.as_array().ok_or_else(|| {
Error::Unsupported(format!("Form XObject {xobject_ref} has no /BBox array"))
})?;
if arr.len() < 4 {
return Err(Error::Unsupported(format!(
"Form XObject {xobject_ref} /BBox has {} elements, expected 4",
arr.len()
)));
}
let bbox = [
as_f64(&arr[0]),
as_f64(&arr[1]),
as_f64(&arr[2]),
as_f64(&arr[3]),
];
Ok((bbox, matrix))
}
fn page_dictionary<R: Read + Seek>(pdf: &mut Pdf<R>, page_ref: ObjectRef) -> Result<Dictionary> {
match pdf.resolve(page_ref)? {
Object::Dictionary(d) => Ok(d),
_ => Err(Error::Unsupported(format!(
"page {page_ref} is not a dictionary"
))),
}
}
fn next_object_ref<R: Read + Seek>(pdf: &Pdf<R>) -> Result<ObjectRef> {
let n = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
Ok(ObjectRef::new(n, 0))
}
#[cfg(all(test, feature = "qpdf-zlib-compat"))]
mod byte_gate {
use super::{
apply_overlay_spec, apply_overlay_specs, apply_overlays_to_page, OverlayKind,
OverlaySource, OverlaySpec,
};
use crate::page_form_xobject::import_page_as_form_xobject;
use crate::page_range::PageRange;
use crate::pages::page_refs;
use crate::{write_pdf_with_options, NewlineBeforeEndstream, Pdf, WriteOptions};
use std::path::Path;
fn fixture(name: &str) -> Pdf<std::io::BufReader<std::fs::File>> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(name);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
Pdf::open(std::io::BufReader::new(file)).unwrap()
}
fn golden(name: &str) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/golden/references/overlay")
.join(name);
std::fs::read(&path).unwrap_or_else(|e| panic!("read golden {path:?}: {e}"))
}
fn pr(input: &str) -> PageRange {
PageRange::parse(input).unwrap_or_else(|e| panic!("parse {input:?}: {e}"))
}
fn write_static_id<R: std::io::Read + std::io::Seek>(dest: &mut Pdf<R>) -> Vec<u8> {
let opts = WriteOptions {
full_rewrite: true,
static_id: true,
newline_before_endstream: NewlineBeforeEndstream::Never,
..Default::default()
};
let mut out = Vec::new();
write_pdf_with_options(dest, &mut out, &opts).unwrap();
out
}
fn first_diff(a: &[u8], b: &[u8]) -> Option<usize> {
if a == b {
return None;
}
let common = a.len().min(b.len());
(0..common).find(|&i| a[i] != b[i]).or(Some(common))
}
fn assert_byte_identical(actual: &[u8], golden_name: &str) {
let expected = golden(golden_name);
if let Some(off) = first_diff(actual, &expected) {
let lo = off.saturating_sub(24);
let g = expected.get(off).copied().unwrap_or(0);
let f = actual.get(off).copied().unwrap_or(0);
panic!(
"overlay output not byte-identical to qpdf golden {golden_name} \
(flpdf={} bytes, golden={} bytes)\n\
first diff at offset {off} (golden=0x{g:02x} flpdf=0x{f:02x})\n\
golden[{lo}..]: {:?}\nflpdf [{lo}..]: {:?}",
actual.len(),
expected.len(),
String::from_utf8_lossy(&expected[lo..(off + 24).min(expected.len())]),
String::from_utf8_lossy(&actual[lo..(off + 24).min(actual.len())]),
);
}
}
#[test]
fn three_page_overlay_one_page_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("one-page.pdf");
let source_page = page_refs(&mut source).unwrap()[0];
let dest_page = page_refs(&mut dest).unwrap()[0];
let imported = import_page_as_form_xobject(&mut dest, &mut source, source_page).unwrap();
apply_overlays_to_page(
&mut dest,
dest_page,
&[OverlaySource {
kind: OverlayKind::Overlay,
xobject_ref: imported,
}],
)
.unwrap();
let opts = WriteOptions {
full_rewrite: true,
static_id: true,
newline_before_endstream: NewlineBeforeEndstream::Never,
..Default::default()
};
let mut actual = Vec::new();
write_pdf_with_options(&mut dest, &mut actual, &opts).unwrap();
let expected = golden("three-page-overlay-one-page.pdf");
if let Some(off) = first_diff(&actual, &expected) {
let lo = off.saturating_sub(24);
let g = expected.get(off).copied().unwrap_or(0);
let f = actual.get(off).copied().unwrap_or(0);
panic!(
"overlay output not byte-identical to qpdf golden \
(flpdf={} bytes, golden={} bytes)\n\
first diff at offset {off} (golden=0x{g:02x} flpdf=0x{f:02x})\n\
golden[{lo}..]: {:?}\nflpdf [{lo}..]: {:?}",
actual.len(),
expected.len(),
String::from_utf8_lossy(&expected[lo..(off + 24).min(expected.len())]),
String::from_utf8_lossy(&actual[lo..(off + 24).min(actual.len())]),
);
}
}
#[test]
fn overlay_two_page_default_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("two-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-two-page.pdf");
}
#[test]
fn overlay_one_page_repeat1_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
Some(&pr("1")),
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-one-page-repeat1.pdf");
}
#[test]
fn overlay_two_page_to2_3_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("two-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr("2-3"),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-two-page-to2-3.pdf");
}
#[test]
fn overlay_two_page_from2_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("two-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr("2"),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-two-page-from2.pdf");
}
#[test]
fn overlay_two_page_from_empty_repeat2_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("two-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&PageRange::empty(),
&pr(""),
Some(&pr("2")),
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(
&actual,
"three-page-overlay-two-page-from-empty-repeat2.pdf",
);
}
#[test]
fn underlay_two_page_default_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("two-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Underlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-underlay-two-page.pdf");
}
#[test]
fn overlay_rotated_source_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("one-page-r90.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-rotated.pdf");
}
#[test]
fn overlay_one_page_to1_3_repeat1_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr("1-3"),
Some(&pr("1")),
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-to-repeat.pdf");
}
#[test]
fn overlay_multi_stream_source_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("multi-stream-one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-multi-stream.pdf");
}
#[test]
fn overlay_onto_rotated_dest_is_byte_identical() {
let mut dest = fixture("one-page-r90.pdf");
let mut source = fixture("one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "r90-dest-overlay-one-page.pdf");
}
#[test]
fn overlay_userunit_source_is_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut source = fixture("userunit-one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-userunit.pdf");
}
fn spec(name: &str, kind: OverlayKind) -> OverlaySpec<std::io::BufReader<std::fs::File>> {
OverlaySpec {
source: fixture(name),
kind,
from: pr(""),
to: pr(""),
repeat: None,
}
}
#[test]
fn two_overlays_compose_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut specs = vec![
spec("one-page.pdf", OverlayKind::Overlay),
spec("two-page.pdf", OverlayKind::Overlay),
];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-two-overlays.pdf");
}
#[test]
fn overlay_and_underlay_compose_byte_identical() {
let mut dest = fixture("three-page.pdf");
let mut specs = vec![
spec("one-page.pdf", OverlayKind::Overlay),
spec("two-page.pdf", OverlayKind::Underlay),
];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "three-page-overlay-and-underlay.pdf");
}
#[test]
fn swapped_box_overlay_one_page_is_byte_identical() {
let mut dest = fixture("swapped-box-one-page.pdf");
let mut source = fixture("one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "swapped-box-overlay-one-page.pdf");
}
#[test]
fn swapped_box_r90_overlay_self_is_byte_identical() {
let mut dest = fixture("swapped-box-r90-one-page.pdf");
let mut source = fixture("swapped-box-r90-one-page.pdf");
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let actual = write_static_id(&mut dest);
assert_byte_identical(&actual, "swapped-box-r90-overlay-self.pdf");
}
use std::io::{Read, Seek};
fn accumulate_max<R1: Read + Seek, R2: Read + Seek>(
a: &mut Pdf<R1>,
b: &mut Pdf<R2>,
) -> ((u8, u8), i64) {
let va = crate::writer::parse_pdf_version(a.version()).unwrap_or((1, 0));
let vb = crate::writer::parse_pdf_version(b.version()).unwrap_or((1, 0));
let ea = a.adobe_extension_level().unwrap_or(0);
let eb = b.adobe_extension_level().unwrap_or(0);
match va.cmp(&vb) {
std::cmp::Ordering::Greater => (va, ea),
std::cmp::Ordering::Less => (vb, eb),
std::cmp::Ordering::Equal => (va, ea.max(eb)),
}
}
fn fixture_path(rel: &str) -> std::path::PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../..")
.join(rel)
}
#[test]
fn overlay_pure_source_version_floor_bytes() {
use std::fs;
let dest_bytes = fs::read(fixture_path("tests/fixtures/compat/three-page.pdf"))
.expect("read dest fixture");
let source_bytes = fs::read(fixture_path("tests/fixtures/compat/one-page-v17.pdf"))
.expect("read source fixture");
let golden = fs::read(fixture_path(
"tests/golden/references/overlay/three-page-overlay-v17-source.pdf",
))
.expect("read golden");
let mut dest = Pdf::open(std::io::Cursor::new(dest_bytes)).expect("open dest");
let mut src = Pdf::open(std::io::Cursor::new(source_bytes)).expect("open source");
let ((maj, min), max_ext) = accumulate_max(&mut dest, &mut src);
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: None,
}];
apply_overlay_specs(&mut dest, &mut specs).expect("apply overlay");
let opts = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some(format!("{maj}.{min}")),
min_extension_level: (max_ext > 0).then_some(max_ext),
newline_before_endstream: NewlineBeforeEndstream::Never,
..Default::default()
};
let mut out = Vec::new();
write_pdf_with_options(&mut dest, &mut out, &opts).expect("write");
if let Some(off) = first_diff(&out, &golden) {
let lo = off.saturating_sub(24);
let g = golden.get(off).copied().unwrap_or(0);
let f = out.get(off).copied().unwrap_or(0);
panic!(
"overlay output not byte-identical to qpdf golden \
three-page-overlay-v17-source.pdf \
(flpdf={} bytes, golden={} bytes)\n\
first diff at offset {off} (golden=0x{g:02x} flpdf=0x{f:02x})\n\
golden[{lo}..]: {:?}\nflpdf [{lo}..]: {:?}",
out.len(),
golden.len(),
String::from_utf8_lossy(&golden[lo..(off + 24).min(golden.len())]),
String::from_utf8_lossy(&out[lo..(off + 24).min(out.len())]),
);
}
}
#[test]
fn overlay_encrypted_source_extension_level_bytes() {
use std::fs;
let dest_bytes = fs::read(fixture_path("tests/fixtures/compat/three-page.pdf"))
.expect("read dest fixture");
let source_bytes = fs::read(fixture_path("tests/fixtures/compat/one-page-enc-u.pdf"))
.expect("read encrypted source fixture");
let golden = fs::read(fixture_path(
"tests/golden/references/overlay/three-page-overlay-encrypted-source.pdf",
))
.expect("read encrypted-source golden");
let mut dest = Pdf::open(std::io::Cursor::new(dest_bytes)).expect("open dest");
let src_open_opts = crate::PdfOpenOptions {
password: b"u".to_vec(),
..crate::PdfOpenOptions::default()
};
let mut src = Pdf::open_with_options(std::io::Cursor::new(source_bytes), src_open_opts)
.expect("open encrypted source");
let ((maj, min), max_ext) = accumulate_max(&mut dest, &mut src);
let mut specs = vec![OverlaySpec {
source: src,
kind: OverlayKind::Overlay,
from: pr(""),
to: pr(""),
repeat: None,
}];
apply_overlay_specs(&mut dest, &mut specs).expect("apply overlay");
let opts = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some(format!("{maj}.{min}")),
min_extension_level: (max_ext > 0).then_some(max_ext),
newline_before_endstream: NewlineBeforeEndstream::Never,
..Default::default()
};
let mut out = Vec::new();
write_pdf_with_options(&mut dest, &mut out, &opts).expect("write");
if let Some(off) = first_diff(&out, &golden) {
let lo = off.saturating_sub(24);
let g = golden.get(off).copied().unwrap_or(0);
let f = out.get(off).copied().unwrap_or(0);
panic!(
"overlay output not byte-identical to qpdf golden \
three-page-overlay-encrypted-source.pdf \
(flpdf={} bytes, golden={} bytes)\n\
first diff at offset {off} (golden=0x{g:02x} flpdf=0x{f:02x})\n\
golden[{lo}..]: {:?}\nflpdf [{lo}..]: {:?}",
out.len(),
golden.len(),
String::from_utf8_lossy(&golden[lo..(off + 24).min(golden.len())]),
String::from_utf8_lossy(&out[lo..(off + 24).min(out.len())]),
);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn fmt_number_matches_qpdf_double_to_string() {
assert_eq!(fmt_number(1.0), "1");
assert_eq!(fmt_number(0.0), "0");
assert_eq!(fmt_number(155.5), "155.5");
assert_eq!(fmt_number(0.181818_1818), "0.18182");
assert_eq!(fmt_number(94.363_636_36), "94.36364");
}
#[test]
fn fmt_number_normalizes_negative_zero() {
assert_eq!(fmt_number(-0.0), "0");
assert_eq!(fmt_number(-0.000001), "0");
}
#[test]
fn qpdf_concat_matches_qpdf_arithmetic() {
assert_eq!(
qpdf_concat(
[2.0, 0.0, 0.0, 2.0, 0.0, 0.0],
[1.0, 0.0, 0.0, 1.0, 5.0, 7.0]
),
[2.0, 0.0, 0.0, 2.0, 10.0, 14.0]
);
}
#[test]
fn matrix_unparse_applies_fix_rounding_and_trims() {
assert_eq!(
matrix_unparse([0.000_004, 1.0, 0.0, 1.0, 0.0, 0.0]),
"0 1 0 1 0 0"
);
assert_eq!(
matrix_unparse([0.772_73, 0.0, 0.0, 0.772_73, 0.0, 159.545_45]),
"0.77273 0 0 0.77273 0 159.54545"
);
}
const ID: [f64; 6] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
#[test]
fn place_identity_when_same_size() {
let frag = place_form_xobject(
[0.0, 0.0, 612.0, 792.0],
ID,
[0.0, 0.0, 612.0, 792.0],
ID,
true,
false,
"Fx0",
);
assert_eq!(frag, "q\n1 0 0 1 0 0 cm\n/Fx0 Do\nQ\n");
}
#[test]
fn place_centers_smaller_bbox_without_scaling() {
let frag = place_form_xobject(
[0.0, 0.0, 300.0, 144.0],
ID,
[0.0, 0.0, 612.0, 792.0],
ID,
true,
false,
"Fx1",
);
assert_eq!(frag, "q\n1 0 0 1 156 324 cm\n/Fx1 Do\nQ\n");
}
#[test]
fn place_shrinks_larger_bbox_to_fit() {
let frag = place_form_xobject(
[0.0, 0.0, 612.0, 792.0],
ID,
[0.0, 0.0, 300.0, 144.0],
ID,
true,
false,
"Fx0",
);
assert_eq!(frag, "q\n0.18182 0 0 0.18182 94.36364 0 cm\n/Fx0 Do\nQ\n");
}
#[test]
fn place_allow_shrink_false_clamps_scale_to_one() {
let frag = place_form_xobject(
[0.0, 0.0, 612.0, 792.0],
ID,
[0.0, 0.0, 300.0, 144.0],
ID,
false,
false,
"Fx0",
);
assert_eq!(frag, "q\n1 0 0 1 -156 -324 cm\n/Fx0 Do\nQ\n");
}
#[test]
fn place_fractional_center() {
let frag = place_form_xobject(
[0.0, 0.0, 301.0, 145.0],
ID,
[0.0, 0.0, 612.0, 792.0],
ID,
true,
false,
"Fx2",
);
assert_eq!(frag, "q\n1 0 0 1 155.5 323.5 cm\n/Fx2 Do\nQ\n");
}
#[test]
fn place_handles_zero_area_bbox_as_identity() {
let frag = place_form_xobject(
[0.0, 0.0, 0.0, 100.0],
ID,
[0.0, 0.0, 200.0, 200.0],
ID,
true,
false,
"Fx1",
);
assert_eq!(frag, "q\n1 0 0 1 0 0 cm\n/Fx1 Do\nQ\n");
}
#[test]
fn place_uses_nonzero_bbox_origin_center() {
let frag = place_form_xobject(
[10.0, 10.0, 510.0, 610.0],
ID,
[0.0, 0.0, 612.0, 792.0],
ID,
true,
false,
"Fx0",
);
assert_eq!(frag, "q\n1 0 0 1 46 86 cm\n/Fx0 Do\nQ\n");
}
#[test]
fn place_fx0_into_rotated_dest_uses_inverse_transform() {
let tmatrix = [0.0, 1.0, -1.0, 0.0, 792.0, 0.0];
let frag = place_form_xobject(
[0.0, 0.0, 612.0, 792.0],
[0.0, -1.0, 1.0, 0.0, 0.0, 612.0],
[0.0, 0.0, 612.0, 792.0],
tmatrix,
false,
false,
"Fx0",
);
assert_eq!(frag, "q\n0 1 -1 0 612 0 cm\n/Fx0 Do\nQ\n");
}
#[test]
fn normalize_rectangle_orders_swapped_corners() {
assert_eq!(
normalize_rectangle([612.0, 792.0, 0.0, 0.0]),
[0.0, 0.0, 612.0, 792.0]
);
assert_eq!(
normalize_rectangle([0.0, 0.0, 612.0, 792.0]),
[0.0, 0.0, 612.0, 792.0]
);
}
fn build_pdf(objects: &[(u32, &str)], root: u32) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let mut offsets: std::collections::BTreeMap<u32, u64> = std::collections::BTreeMap::new();
let max = objects.iter().map(|(n, _)| *n).max().unwrap_or(0);
for (n, body) in objects {
offsets.insert(*n, out.len() as u64);
out.extend_from_slice(format!("{n} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let size = max + 1;
out.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for n in 1..=max {
let off = offsets
.get(&n)
.expect("test fixtures use contiguous object numbers");
out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root {root} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
fn open(bytes: Vec<u8>) -> Pdf<std::io::Cursor<Vec<u8>>> {
Pdf::open_mem_owned(bytes).unwrap()
}
fn one_page_doc(content: &str) -> Vec<u8> {
let content_body = format!(
"<< /Length {} >>\nstream\n{content}\nendstream",
content.len()
);
build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R /Rotate 0 >>",
),
(4, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"),
(5, &content_body),
],
1,
)
}
fn insert_form_xobject<R: Read + Seek>(
pdf: &mut Pdf<R>,
bbox: [i64; 4],
content: &[u8],
) -> ObjectRef {
let mut dict = Dictionary::new();
dict.insert("Type", Object::Name(b"XObject".to_vec()));
dict.insert("Subtype", Object::Name(b"Form".to_vec()));
dict.insert(
"BBox",
Object::Array(bbox.iter().map(|v| Object::Integer(*v)).collect()),
);
let r = next_object_ref(pdf).unwrap();
pdf.set_object(r, Object::Stream(Stream::new(dict, content.to_vec())));
r
}
#[test]
fn apply_single_overlay_rebuilds_resources_and_contents() {
let mut pdf = open(one_page_doc("page content"));
let page_ref = ObjectRef::new(3, 0);
let overlay = insert_form_xobject(&mut pdf, [0, 0, 612, 792], b"overlay content");
apply_overlays_to_page(
&mut pdf,
page_ref,
&[OverlaySource {
kind: OverlayKind::Overlay,
xobject_ref: overlay,
}],
)
.unwrap();
let page = pdf.resolve(page_ref).unwrap();
let page_dict = page.as_dict().unwrap();
let res = page_dict.get("Resources").unwrap().as_dict().unwrap();
let keys: Vec<&[u8]> = res.iter().map(|(k, _)| k).collect();
assert_eq!(keys, vec![b"XObject".as_slice()]);
let xobj = res.get("XObject").unwrap().as_dict().unwrap();
let xkeys: std::collections::BTreeSet<Vec<u8>> =
xobj.iter().map(|(k, _)| k.to_vec()).collect();
let expected: std::collections::BTreeSet<Vec<u8>> =
[b"Fx0".to_vec(), b"Fx1".to_vec()].into_iter().collect();
assert_eq!(xkeys, expected);
assert!(res.get("Font").is_none());
let contents_ref = match page_dict.get("Contents") {
Some(Object::Reference(r)) => *r,
other => panic!("Contents should be a reference, got {other:?}"), };
let stream = pdf
.resolve(contents_ref)
.unwrap()
.into_stream()
.expect("Contents must be a stream");
assert_eq!(
stream.data,
b"q\n1 0 0 1 0 0 cm\n/Fx0 Do\nQ\nq\n1 0 0 1 0 0 cm\n/Fx1 Do\nQ\n".to_vec()
);
assert_eq!(stream.data.len(), 54);
assert_eq!(
page_dict.get("Type").unwrap().as_name(),
Some(b"Page".as_slice())
);
assert!(page_dict.get("MediaBox").is_some());
assert!(page_dict.get("Rotate").is_some());
let fx0_ref = match xobj.get("Fx0") {
Some(Object::Reference(r)) => *r,
other => panic!("Fx0 should be a reference, got {other:?}"), };
let fx0 = pdf.resolve(fx0_ref).unwrap().into_stream().unwrap();
assert_eq!(
fx0.dict.get("Subtype").unwrap().as_name(),
Some(b"Form".as_slice())
);
let fx0_res = fx0.dict.get("Resources").unwrap().as_dict().unwrap();
assert!(fx0_res.get("Font").is_some(), "Fx0 keeps the page's /Font");
}
#[test]
fn apply_orders_underlays_then_overlays_in_naming_and_drawing() {
let mut pdf = open(one_page_doc("page content"));
let page_ref = ObjectRef::new(3, 0);
let overlay = insert_form_xobject(&mut pdf, [0, 0, 612, 792], b"over");
let underlay = insert_form_xobject(&mut pdf, [0, 0, 612, 792], b"under");
apply_overlays_to_page(
&mut pdf,
page_ref,
&[
OverlaySource {
kind: OverlayKind::Overlay,
xobject_ref: overlay,
},
OverlaySource {
kind: OverlayKind::Underlay,
xobject_ref: underlay,
},
],
)
.unwrap();
let page = pdf.resolve(page_ref).unwrap();
let page_dict = page.as_dict().unwrap();
let res = page_dict.get("Resources").unwrap().as_dict().unwrap();
let xobj = res.get("XObject").unwrap().as_dict().unwrap();
let fx1 = match xobj.get("Fx1") {
Some(Object::Reference(r)) => *r,
other => panic!("Fx1 missing: {other:?}"), };
let fx2 = match xobj.get("Fx2") {
Some(Object::Reference(r)) => *r,
other => panic!("Fx2 missing: {other:?}"), };
assert_eq!(fx1, underlay, "underlay must be /Fx1");
assert_eq!(fx2, overlay, "overlay must be /Fx2");
let contents_ref = match page_dict.get("Contents") {
Some(Object::Reference(r)) => *r,
other => panic!("Contents ref: {other:?}"), };
let stream = pdf.resolve(contents_ref).unwrap().into_stream().unwrap();
let text = String::from_utf8(stream.data).unwrap();
let fx1_pos = text.find("/Fx1 Do").unwrap();
let fx0_pos = text.find("/Fx0 Do").unwrap();
let fx2_pos = text.find("/Fx2 Do").unwrap();
assert!(
fx1_pos < fx0_pos && fx0_pos < fx2_pos,
"draw order must be Fx1 (under) -> Fx0 (page) -> Fx2 (over): {text:?}"
);
}
#[test]
fn apply_places_fx0_in_mediabox_and_source_in_trimbox() {
let content_body = "<< /Length 1 >>\nstream\nx\nendstream";
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/CropBox [0 0 600 700] /TrimBox [10 10 500 600] \
/Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>",
),
(4, "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"),
(5, content_body),
],
1,
));
let page_ref = ObjectRef::new(3, 0);
let src = insert_form_xobject(&mut pdf, [20, 20, 220, 100], b"src");
apply_overlays_to_page(
&mut pdf,
page_ref,
&[OverlaySource {
kind: OverlayKind::Overlay,
xobject_ref: src,
}],
)
.unwrap();
let page = pdf.resolve(page_ref).unwrap();
let contents_ref = match page.as_dict().unwrap().get("Contents") {
Some(Object::Reference(r)) => *r,
other => panic!("Contents ref: {other:?}"), };
let stream = pdf.resolve(contents_ref).unwrap().into_stream().unwrap();
let text = String::from_utf8(stream.data).unwrap();
assert!(
text.contains("q\n1 0 0 1 51 91 cm\n/Fx0 Do\nQ\n"),
"Fx0 must place into the dest MediaBox: {text:?}"
);
assert!(
text.contains("q\n1 0 0 1 135 245 cm\n/Fx1 Do\nQ\n"),
"source must place into the dest TrimBox: {text:?}"
);
}
fn overlay_contents(media_box: &str, rotate: &str) -> Vec<u8> {
let page = format!(
"<< /Type /Page /Parent 2 0 R /MediaBox {media_box} {rotate} \
/Resources << >> /Contents 4 0 R >>"
);
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, &page),
(4, "<< /Length 1 >>\nstream\nx\nendstream"),
],
1,
));
let page_ref = ObjectRef::new(3, 0);
let src = insert_form_xobject(&mut pdf, [0, 0, 100, 100], b"src");
apply_overlays_to_page(
&mut pdf,
page_ref,
&[OverlaySource {
kind: OverlayKind::Overlay,
xobject_ref: src,
}],
)
.unwrap();
let contents_ref = match pdf
.resolve(page_ref)
.unwrap()
.as_dict()
.unwrap()
.get("Contents")
{
Some(Object::Reference(r)) => *r,
other => panic!("Contents ref: {other:?}"), };
pdf.resolve(contents_ref)
.unwrap()
.into_stream()
.unwrap()
.data
}
#[test]
fn apply_swapped_mediabox_normalizes_placement_rect() {
let text = String::from_utf8(overlay_contents("[612 792 0 0]", "")).unwrap();
assert!(
text.contains("q\n1 0 0 1 256 346 cm\n/Fx1 Do\nQ\n"),
"source must place into the normalized MediaBox: {text:?}"
);
}
#[test]
fn apply_swapped_box_with_rotate_matches_normalized() {
let swapped = overlay_contents("[612 792 0 0]", "/Rotate 90");
let normalized = overlay_contents("[0 0 612 792]", "/Rotate 90");
assert_eq!(swapped, normalized);
}
#[test]
fn apply_rejects_non_page() {
let mut pdf = open(one_page_doc("x"));
let err = apply_overlays_to_page(&mut pdf, ObjectRef::new(2, 0), &[]);
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn page_box_or_err_errors_when_box_absent() {
let mut pdf = open(build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>"),
(3, "<< /Type /Page /Parent 2 0 R >>"),
],
1,
));
let err = page_box_or_err(&mut pdf, ObjectRef::new(3, 0), BoxKind::Media);
assert!(matches!(err, Err(Error::Unsupported(_))));
}
#[test]
fn xobject_bbox_reads_real_and_integer_elements() {
let mut pdf = open(one_page_doc("x"));
let mut dict = Dictionary::new();
dict.insert("Subtype", Object::Name(b"Form".to_vec()));
dict.insert(
"BBox",
Object::Array(vec![
Object::Integer(0),
Object::Real(1.5),
Object::Integer(300),
Object::Real(144.0),
]),
);
let r = next_object_ref(&pdf).unwrap();
pdf.set_object(r, Object::Stream(Stream::new(dict, Vec::new())));
let (bbox, _matrix) = fo_bbox_and_matrix(&mut pdf, r).unwrap();
assert_eq!(bbox, [0.0, 1.5, 300.0, 144.0]);
}
#[test]
fn fo_bbox_rejects_missing_and_short_box() {
let mut pdf = open(one_page_doc("x"));
let mut d1 = Dictionary::new();
d1.insert("Subtype", Object::Name(b"Form".to_vec()));
let r1 = next_object_ref(&pdf).unwrap();
pdf.set_object(r1, Object::Stream(Stream::new(d1, Vec::new())));
assert!(matches!(
fo_bbox_and_matrix(&mut pdf, r1),
Err(Error::Unsupported(_))
));
let mut d2 = Dictionary::new();
d2.insert("BBox", Object::Array(vec![Object::Integer(0)]));
let r2 = next_object_ref(&pdf).unwrap();
pdf.set_object(r2, Object::Stream(Stream::new(d2, Vec::new())));
assert!(matches!(
fo_bbox_and_matrix(&mut pdf, r2),
Err(Error::Unsupported(_))
));
}
#[test]
fn fo_bbox_rejects_non_stream_non_dict() {
let mut pdf = open(one_page_doc("x"));
let r = next_object_ref(&pdf).unwrap();
pdf.set_object(r, Object::Integer(42));
assert!(matches!(
fo_bbox_and_matrix(&mut pdf, r),
Err(Error::Unsupported(_))
));
}
#[test]
fn fo_bbox_reads_from_plain_dictionary() {
let mut pdf = open(one_page_doc("x"));
let mut d = Dictionary::new();
d.insert(
"BBox",
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(10),
Object::Integer(20),
]),
);
let r = next_object_ref(&pdf).unwrap();
pdf.set_object(r, Object::Dictionary(d));
let (bbox, matrix) = fo_bbox_and_matrix(&mut pdf, r).unwrap();
assert_eq!(bbox, [0.0, 0.0, 10.0, 20.0]);
assert_eq!(matrix, [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
}
#[test]
fn fo_bbox_resolves_indirect_reference() {
let mut pdf = open(one_page_doc("x"));
let bbox_ref = next_object_ref(&pdf).unwrap();
pdf.set_object(
bbox_ref,
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(10),
Object::Integer(20),
]),
);
let mut d = Dictionary::new();
d.insert("BBox", Object::Reference(bbox_ref));
let r = next_object_ref(&pdf).unwrap();
pdf.set_object(r, Object::Dictionary(d));
let (bbox, _matrix) = fo_bbox_and_matrix(&mut pdf, r).unwrap();
assert_eq!(bbox, [0.0, 0.0, 10.0, 20.0]);
}
#[test]
fn page_dictionary_rejects_non_dict() {
let mut pdf = open(one_page_doc("x"));
let r = next_object_ref(&pdf).unwrap();
pdf.set_object(r, Object::Integer(7));
assert!(matches!(
page_dictionary(&mut pdf, r),
Err(Error::Unsupported(_))
));
}
#[test]
fn transform_bbox_identity_is_unchanged() {
let id = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
assert_eq!(
transform_bbox([10.0, 20.0, 300.0, 400.0], id),
[10.0, 20.0, 300.0, 400.0]
);
}
#[test]
fn transform_bbox_rotate_90_swaps_extent() {
let m90 = [0.0, -1.0, 1.0, 0.0, 0.0, 612.0];
assert_eq!(
transform_bbox([0.0, 0.0, 612.0, 792.0], m90),
[0.0, 0.0, 792.0, 612.0]
);
}
#[test]
fn matrix_or_identity_reads_present_absent_and_short() {
let mut present = Dictionary::new();
present.insert(
"Matrix",
Object::Array(vec![
Object::Integer(0),
Object::Integer(-1),
Object::Integer(1),
Object::Integer(0),
Object::Integer(0),
Object::Real(612.0),
]),
);
assert_eq!(
matrix_or_identity(&present),
[0.0, -1.0, 1.0, 0.0, 0.0, 612.0]
);
assert_eq!(
matrix_or_identity(&Dictionary::new()),
[1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
);
let mut short = Dictionary::new();
short.insert(
"Matrix",
Object::Array(vec![Object::Integer(1), Object::Integer(0)]),
);
assert_eq!(matrix_or_identity(&short), [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]);
}
#[test]
fn place_uses_matrix_transformed_bbox_for_rotated_form() {
let frag = place_form_xobject(
[0.0, 0.0, 612.0, 792.0],
[0.0, -1.0, 1.0, 0.0, 0.0, 612.0],
[0.0, 0.0, 612.0, 792.0],
ID,
true,
false,
"Fx1",
);
assert_eq!(frag, "q\n0.77273 0 0 0.77273 0 159.54545 cm\n/Fx1 Do\nQ\n");
}
#[test]
fn fo_bbox_and_matrix_reads_bbox_and_matrix() {
let mut pdf = open(one_page_doc("x"));
let mut d = Dictionary::new();
d.insert(
"BBox",
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
]),
);
d.insert(
"Matrix",
Object::Array(vec![
Object::Integer(0),
Object::Integer(-1),
Object::Integer(1),
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
]),
);
let r = next_object_ref(&pdf).unwrap();
pdf.set_object(r, Object::Dictionary(d));
let (bbox, matrix) = fo_bbox_and_matrix(&mut pdf, r).unwrap();
assert_eq!(bbox, [0.0, 0.0, 612.0, 792.0]);
assert_eq!(matrix, [0.0, -1.0, 1.0, 0.0, 0.0, 612.0]);
}
fn pr(input: &str) -> PageRange {
PageRange::parse(input).unwrap_or_else(|e| panic!("parse {input:?}: {e}"))
}
#[test]
fn map_two_page_default_pairs_in_order_and_skips_extra() {
let from = pr("").resolve(2).unwrap();
let to = pr("").resolve(3).unwrap();
assert_eq!(map_overlay_pages(&from, &to, &[]), vec![(1, 1), (2, 2)]);
}
#[test]
fn map_one_page_repeat1_cycles_single_source_over_all_dest() {
let from = pr("").resolve(1).unwrap();
let to = pr("").resolve(3).unwrap();
let repeat = pr("1").resolve(1).unwrap();
assert_eq!(
map_overlay_pages(&from, &to, &repeat),
vec![(1, 1), (2, 1), (3, 1)]
);
}
#[test]
fn map_to_2_3_pairs_against_the_to_list() {
let from = pr("").resolve(2).unwrap();
let to = pr("2-3").resolve(3).unwrap();
assert_eq!(map_overlay_pages(&from, &to, &[]), vec![(2, 1), (3, 2)]);
}
#[test]
fn map_from_2_uses_offset_source_then_exhausts() {
let from = pr("2").resolve(2).unwrap();
let to = pr("").resolve(3).unwrap();
assert_eq!(map_overlay_pages(&from, &to, &[]), vec![(1, 2)]);
}
#[test]
fn map_to_1_3_skips_unpaired_dest_when_source_exhausted() {
let from = pr("").resolve(1).unwrap();
let to = pr("1,3").resolve(3).unwrap();
assert_eq!(map_overlay_pages(&from, &to, &[]), vec![(1, 1)]);
}
#[test]
fn map_repeat_2_cycles_last_source_past_exhaustion() {
let from = pr("").resolve(2).unwrap();
let to = pr("").resolve(3).unwrap();
let repeat = pr("2").resolve(2).unwrap();
assert_eq!(
map_overlay_pages(&from, &to, &repeat),
vec![(1, 1), (2, 2), (3, 2)]
);
}
#[test]
fn map_repeat_cycles_when_more_dest_than_repeat_pages() {
let from: Vec<u32> = Vec::new();
let to = vec![1, 2, 3, 4];
let repeat = vec![3, 4];
assert_eq!(
map_overlay_pages(&from, &to, &repeat),
vec![(1, 3), (2, 4), (3, 3), (4, 4)]
);
}
fn multi_page_doc(count: u32) -> Vec<u8> {
assert!(count >= 1);
let mut objs: Vec<(u32, String)> = Vec::new();
objs.push((1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()));
let kids: Vec<String> = (0..count).map(|i| format!("{} 0 R", 3 + i)).collect();
objs.push((
2,
format!(
"<< /Type /Pages /Kids [{}] /Count {count} >>",
kids.join(" ")
),
));
let font_obj = 3 + count * 2;
for i in 0..count {
let page_num = i + 1;
let page_obj = 3 + i;
let content_obj = 3 + count + i;
objs.push((
page_obj,
format!(
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Resources << /Font << /F1 {font_obj} 0 R >> >> /Contents {content_obj} 0 R >>"
),
));
let content = format!("page {page_num} content");
let body = format!(
"<< /Length {} >>\nstream\n{content}\nendstream",
content.len()
);
objs.push((content_obj, body));
}
objs.push((
font_obj,
"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".to_string(),
));
let borrowed: Vec<(u32, &str)> = objs.iter().map(|(n, b)| (*n, b.as_str())).collect();
build_pdf(&borrowed, 1)
}
fn fx1_ref<R: Read + Seek>(pdf: &mut Pdf<R>, page_ref: ObjectRef) -> ObjectRef {
let page = pdf.resolve(page_ref).unwrap();
let res = page
.as_dict()
.unwrap()
.get("Resources")
.unwrap()
.as_dict()
.unwrap();
let xobj = res.get("XObject").unwrap().as_dict().unwrap();
match xobj.get("Fx1") {
Some(Object::Reference(r)) => *r,
other => panic!("Fx1 should be a reference, got {other:?}"), }
}
fn is_patched<R: Read + Seek>(pdf: &mut Pdf<R>, page_ref: ObjectRef) -> bool {
let page = pdf.resolve(page_ref).unwrap();
let res = page
.as_dict()
.unwrap()
.get("Resources")
.unwrap()
.as_dict()
.unwrap();
res.get("XObject").is_some() && res.get("Font").is_none()
}
#[test]
fn apply_overlay_spec_two_page_default_shares_nothing_and_skips_third() {
let mut dest = open(multi_page_doc(3));
let mut source = open(multi_page_doc(2));
let dest_pages = page_refs(&mut dest).unwrap();
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
assert!(is_patched(&mut dest, dest_pages[0]), "p1 patched");
assert!(is_patched(&mut dest, dest_pages[1]), "p2 patched");
assert!(!is_patched(&mut dest, dest_pages[2]), "p3 untouched");
let fx1_p1 = fx1_ref(&mut dest, dest_pages[0]);
let fx1_p2 = fx1_ref(&mut dest, dest_pages[1]);
assert_ne!(
fx1_p1, fx1_p2,
"distinct source pages import distinct XObjects"
);
}
#[test]
fn apply_overlay_spec_repeat_shares_single_source_xobject() {
let mut dest = open(multi_page_doc(3));
let mut source = open(multi_page_doc(1));
let dest_pages = page_refs(&mut dest).unwrap();
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr(""),
Some(&pr("1")),
)
.unwrap();
let fx1_p1 = fx1_ref(&mut dest, dest_pages[0]);
let fx1_p2 = fx1_ref(&mut dest, dest_pages[1]);
let fx1_p3 = fx1_ref(&mut dest, dest_pages[2]);
assert_eq!(fx1_p1, fx1_p2, "same source -> shared XObject ref");
assert_eq!(fx1_p2, fx1_p3, "same source -> shared XObject ref");
let fx0 = |pdf: &mut Pdf<_>, page_ref: ObjectRef| -> ObjectRef {
let page = pdf.resolve(page_ref).unwrap();
let xobj = page
.as_dict()
.unwrap()
.get("Resources")
.unwrap()
.as_dict()
.unwrap()
.get("XObject")
.unwrap()
.as_dict()
.unwrap();
match xobj.get("Fx0") {
Some(Object::Reference(r)) => *r,
other => panic!("Fx0 ref: {other:?}"), }
};
let fx0_p1 = fx0(&mut dest, dest_pages[0]);
let fx0_p2 = fx0(&mut dest, dest_pages[1]);
assert_ne!(fx0_p1, fx0_p2, "each page's own Fx0 is distinct");
}
#[test]
fn apply_overlay_spec_to_range_leaves_unselected_dest_untouched() {
let mut dest = open(multi_page_doc(3));
let mut source = open(multi_page_doc(2));
let dest_pages = page_refs(&mut dest).unwrap();
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr(""),
&pr("2-3"),
None,
)
.unwrap();
assert!(!is_patched(&mut dest, dest_pages[0]), "p1 untouched");
assert!(is_patched(&mut dest, dest_pages[1]), "p2 patched");
assert!(is_patched(&mut dest, dest_pages[2]), "p3 patched");
}
#[test]
fn apply_overlay_spec_underlay_kind_is_threaded_through() {
let mut dest = open(multi_page_doc(1));
let mut source = open(multi_page_doc(1));
let dest_pages = page_refs(&mut dest).unwrap();
apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Underlay,
&pr(""),
&pr(""),
None,
)
.unwrap();
let page = dest.resolve(dest_pages[0]).unwrap();
let contents_ref = match page.as_dict().unwrap().get("Contents") {
Some(Object::Reference(r)) => *r,
other => panic!("Contents ref: {other:?}"), };
let stream = dest.resolve(contents_ref).unwrap().into_stream().unwrap();
let text = String::from_utf8(stream.data).unwrap();
let fx1 = text.find("/Fx1 Do").unwrap();
let fx0 = text.find("/Fx0 Do").unwrap();
assert!(fx1 < fx0, "underlay /Fx1 must draw before /Fx0: {text:?}");
}
#[test]
fn apply_overlay_spec_errors_on_out_of_range_from() {
let mut dest = open(multi_page_doc(2));
let mut source = open(multi_page_doc(2));
let err = apply_overlay_spec(
&mut dest,
&mut source,
OverlayKind::Overlay,
&pr("5"),
&pr(""),
None,
);
assert!(matches!(err, Err(Error::Parse { .. })));
}
#[test]
fn page_ref_for_errors_when_out_of_range() {
let pages = vec![ObjectRef::new(3, 0), ObjectRef::new(4, 0)];
assert!(matches!(
page_ref_for(&pages, 3, "source"),
Err(Error::Unsupported(_))
));
assert!(matches!(
page_ref_for(&pages, 0, "destination"),
Err(Error::Unsupported(_))
));
assert_eq!(page_ref_for(&pages, 1, "source").unwrap(), pages[0]);
assert_eq!(page_ref_for(&pages, 2, "source").unwrap(), pages[1]);
}
#[test]
fn u32_len_clamps_oversized_lengths() {
assert_eq!(u32_len(0), 0);
assert_eq!(u32_len(5), 5);
assert_eq!(u32_len(usize::MAX), u32::MAX);
}
fn src(kind: OverlayKind, n: u32) -> OverlaySource {
OverlaySource {
kind,
xobject_ref: ObjectRef::new(n, 0),
}
}
#[test]
fn group_sources_buckets_by_page_in_ascending_order() {
let entries = vec![
(3, src(OverlayKind::Overlay, 10)),
(1, src(OverlayKind::Overlay, 11)),
(3, src(OverlayKind::Overlay, 12)),
];
let grouped = group_sources_by_dest_page(&entries);
let pages: Vec<u32> = grouped.keys().copied().collect();
assert_eq!(pages, vec![1, 3], "pages iterate in ascending order");
let p3: Vec<u32> = grouped[&3].iter().map(|s| s.xobject_ref.number).collect();
assert_eq!(p3, vec![10, 12]);
}
#[test]
fn group_sources_preserves_cross_spec_declaration_order_within_page() {
let entries = vec![
(1, src(OverlayKind::Overlay, 11)),
(1, src(OverlayKind::Underlay, 19)),
];
let grouped = group_sources_by_dest_page(&entries);
let p1 = &grouped[&1];
assert_eq!(p1.len(), 2);
assert_eq!(p1[0].kind, OverlayKind::Overlay);
assert_eq!(p1[0].xobject_ref.number, 11);
assert_eq!(p1[1].kind, OverlayKind::Underlay);
assert_eq!(p1[1].xobject_ref.number, 19);
}
#[test]
fn group_sources_empty_is_empty() {
assert!(group_sources_by_dest_page(&[]).is_empty());
}
#[test]
fn kind_stable_partition_underlays_first_stable_within_group() {
#[derive(Debug, PartialEq)]
struct E(u32, OverlayKind);
let out = kind_stable_partition(
vec![
E(1, OverlayKind::Overlay),
E(2, OverlayKind::Underlay),
E(3, OverlayKind::Overlay),
E(4, OverlayKind::Underlay),
],
|e| e.1,
);
assert_eq!(
out,
vec![
E(2, OverlayKind::Underlay),
E(4, OverlayKind::Underlay),
E(1, OverlayKind::Overlay),
E(3, OverlayKind::Overlay),
],
"underlays first (order preserved), then overlays (order preserved)"
);
let empty: Vec<E> = kind_stable_partition(Vec::new(), |e| e.1);
assert!(empty.is_empty(), "empty input yields empty output");
let all_u = kind_stable_partition(
vec![
E(10, OverlayKind::Underlay),
E(11, OverlayKind::Underlay),
E(12, OverlayKind::Underlay),
],
|e| e.1,
);
assert_eq!(
all_u,
vec![
E(10, OverlayKind::Underlay),
E(11, OverlayKind::Underlay),
E(12, OverlayKind::Underlay),
],
"all-underlays input preserves order (identity)"
);
let all_o = kind_stable_partition(
vec![
E(20, OverlayKind::Overlay),
E(21, OverlayKind::Overlay),
E(22, OverlayKind::Overlay),
],
|e| e.1,
);
assert_eq!(
all_o,
vec![
E(20, OverlayKind::Overlay),
E(21, OverlayKind::Overlay),
E(22, OverlayKind::Overlay),
],
"all-overlays input preserves order (identity)"
);
}
fn page_fx_and_content<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> (BTreeMap<String, ObjectRef>, String) {
let page = pdf.resolve(page_ref).unwrap();
let page_dict = page.as_dict().unwrap();
let xobj = page_dict
.get("Resources")
.unwrap()
.as_dict()
.unwrap()
.get("XObject")
.unwrap()
.as_dict()
.unwrap();
let mut names = BTreeMap::new();
for (k, v) in xobj.iter() {
if let Object::Reference(r) = v {
names.insert(String::from_utf8(k.to_vec()).unwrap(), *r);
}
}
let contents_ref = match page_dict.get("Contents") {
Some(Object::Reference(r)) => *r,
other => panic!("Contents ref: {other:?}"), };
let stream = pdf.resolve(contents_ref).unwrap().into_stream().unwrap();
(names, String::from_utf8(stream.data).unwrap())
}
fn spec(
source: Pdf<std::io::Cursor<Vec<u8>>>,
kind: OverlayKind,
) -> OverlaySpec<std::io::Cursor<Vec<u8>>> {
OverlaySpec {
source,
kind,
from: pr(""),
to: pr(""),
repeat: None,
}
}
#[test]
fn apply_overlay_specs_two_overlays_name_in_declaration_order() {
let mut dest = open(multi_page_doc(3));
let dest_pages = page_refs(&mut dest).unwrap();
let mut specs = vec![
spec(open(multi_page_doc(1)), OverlayKind::Overlay),
spec(open(multi_page_doc(2)), OverlayKind::Overlay),
];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let (names1, text1) = page_fx_and_content(&mut dest, dest_pages[0]);
let keys1: Vec<&str> = {
let mut k: Vec<&str> = names1.keys().map(String::as_str).collect();
k.sort();
k
};
assert_eq!(keys1, vec!["Fx0", "Fx1", "Fx2"], "page 1 has Fx0..Fx2");
let p0 = text1.find("/Fx0 Do").unwrap();
let p1 = text1.find("/Fx1 Do").unwrap();
let p2 = text1.find("/Fx2 Do").unwrap();
assert!(p0 < p1 && p1 < p2, "overlays draw after /Fx0: {text1:?}");
assert_ne!(names1["Fx1"], names1["Fx2"]);
let (names2, _text2) = page_fx_and_content(&mut dest, dest_pages[1]);
let mut keys2: Vec<&str> = names2.keys().map(String::as_str).collect();
keys2.sort();
assert_eq!(keys2, vec!["Fx0", "Fx1"], "page 2 has only one source");
assert!(!is_patched(&mut dest, dest_pages[2]), "page 3 untouched");
}
#[test]
fn apply_overlay_specs_overlay_then_underlay_names_under_first() {
let mut dest = open(multi_page_doc(3));
let dest_pages = page_refs(&mut dest).unwrap();
let mut specs = vec![
spec(open(multi_page_doc(1)), OverlayKind::Overlay),
spec(open(multi_page_doc(2)), OverlayKind::Underlay),
];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let (names1, text1) = page_fx_and_content(&mut dest, dest_pages[0]);
let mut keys1: Vec<&str> = names1.keys().map(String::as_str).collect();
keys1.sort();
assert_eq!(keys1, vec!["Fx0", "Fx1", "Fx2"]);
let f1 = text1.find("/Fx1 Do").unwrap();
let f0 = text1.find("/Fx0 Do").unwrap();
let f2 = text1.find("/Fx2 Do").unwrap();
assert!(
f1 < f0 && f0 < f2,
"under(Fx1) -> page(Fx0) -> over(Fx2): {text1:?}"
);
let (names2, text2) = page_fx_and_content(&mut dest, dest_pages[1]);
let mut keys2: Vec<&str> = names2.keys().map(String::as_str).collect();
keys2.sort();
assert_eq!(keys2, vec!["Fx0", "Fx1"]);
assert!(
text2.find("/Fx1 Do").unwrap() < text2.find("/Fx0 Do").unwrap(),
"page 2 underlay draws before /Fx0: {text2:?}"
);
}
#[test]
fn apply_overlay_specs_applies_each_page_once() {
let mut dest = open(multi_page_doc(1));
let dest_pages = page_refs(&mut dest).unwrap();
let mut specs = vec![
spec(open(multi_page_doc(1)), OverlayKind::Overlay),
spec(open(multi_page_doc(1)), OverlayKind::Overlay),
];
apply_overlay_specs(&mut dest, &mut specs).unwrap();
let (names, text) = page_fx_and_content(&mut dest, dest_pages[0]);
let mut keys: Vec<&str> = names.keys().map(String::as_str).collect();
keys.sort();
assert_eq!(keys, vec!["Fx0", "Fx1", "Fx2"], "one /Fx0, two overlays");
assert_eq!(text.matches("/Fx0 Do").count(), 1, "single /Fx0 draw");
}
#[test]
fn apply_overlay_specs_empty_is_noop() {
let mut dest = open(multi_page_doc(2));
let dest_pages = page_refs(&mut dest).unwrap();
let mut specs: Vec<OverlaySpec<std::io::Cursor<Vec<u8>>>> = Vec::new();
apply_overlay_specs(&mut dest, &mut specs).unwrap();
assert!(!is_patched(&mut dest, dest_pages[0]));
assert!(!is_patched(&mut dest, dest_pages[1]));
}
#[test]
fn apply_overlay_specs_propagates_spec_error() {
let mut dest = open(multi_page_doc(2));
let mut specs = vec![OverlaySpec {
source: open(multi_page_doc(2)),
kind: OverlayKind::Overlay,
from: pr("5"),
to: pr(""),
repeat: None,
}];
let err = apply_overlay_specs(&mut dest, &mut specs);
assert!(matches!(err, Err(Error::Parse { .. })));
}
fn n_page_doc(n: u32) -> Vec<u8> {
assert!(n >= 1);
let kids: Vec<String> = (0..n).map(|i| format!("{} 0 R", 3 + i)).collect();
let mut objects: Vec<(u32, String)> = Vec::new();
objects.push((1, "<< /Type /Catalog /Pages 2 0 R >>".to_string()));
objects.push((
2,
format!("<< /Type /Pages /Kids [{}] /Count {} >>", kids.join(" "), n),
));
for i in 0..n {
objects.push((
3 + i,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << >> >>"
.to_string(),
));
}
let refs: Vec<(u32, &str)> = objects.iter().map(|(n, s)| (*n, s.as_str())).collect();
build_pdf(&refs, 1)
}
#[test]
fn overlay_verbose_report_orders_underlays_then_overlays_across_specs() {
let mut dest = open(n_page_doc(3));
let spec_a = OverlaySpec {
source: open(n_page_doc(1)),
kind: OverlayKind::Overlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("1").unwrap(),
repeat: None,
};
let spec_b = OverlaySpec {
source: open(n_page_doc(1)),
kind: OverlayKind::Overlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("1").unwrap(),
repeat: None,
};
let spec_c = OverlaySpec {
source: open(n_page_doc(1)),
kind: OverlayKind::Underlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("1").unwrap(),
repeat: None,
};
let spec_d = OverlaySpec {
source: open(n_page_doc(1)),
kind: OverlayKind::Underlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("1").unwrap(),
repeat: None,
};
let mut specs = [spec_a, spec_b, spec_c, spec_d];
let report = overlay_verbose_report(&mut dest, &mut specs).unwrap();
assert_eq!(report.len(), 3, "3-page dest -> 3 report entries");
assert_eq!(report[0].dest_page, 1);
let idx: Vec<usize> = report[0].sources.iter().map(|s| s.spec_index).collect();
assert_eq!(
idx,
vec![2, 3, 0, 1],
"underlays first (specs 2,3), then overlays (0,1)"
);
let kinds: Vec<OverlayKind> = report[0].sources.iter().map(|s| s.kind).collect();
assert_eq!(
kinds,
vec![
OverlayKind::Underlay,
OverlayKind::Underlay,
OverlayKind::Overlay,
OverlayKind::Overlay,
],
"sources[0..2] must be underlays, [2..4] overlays"
);
let srcs: Vec<u32> = report[0].sources.iter().map(|s| s.src_page).collect();
assert_eq!(
srcs,
vec![1, 1, 1, 1],
"every spec targets --to=1, src=1 for a 1-page source"
);
assert!(report[1].sources.is_empty());
assert!(report[2].sources.is_empty());
}
#[test]
fn overlay_verbose_report_includes_dest_pages_with_no_sources() {
let mut dest = open(n_page_doc(3));
let spec = OverlaySpec {
source: open(n_page_doc(2)),
kind: OverlayKind::Overlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("1-2").unwrap(),
repeat: None,
};
let mut specs = [spec];
let report = overlay_verbose_report(&mut dest, &mut specs).unwrap();
assert_eq!(report.len(), 3);
assert_eq!(report[0].dest_page, 1);
assert_eq!(report[0].sources.len(), 1);
assert_eq!(report[0].sources[0].src_page, 1);
assert_eq!(report[1].dest_page, 2);
assert_eq!(report[1].sources.len(), 1);
assert_eq!(report[1].sources[0].src_page, 2);
assert_eq!(report[2].dest_page, 3);
assert!(report[2].sources.is_empty());
}
#[test]
fn overlay_verbose_report_pins_source_page_under_repeat() {
let mut dest = open(n_page_doc(5));
let spec = OverlaySpec {
source: open(n_page_doc(2)),
kind: OverlayKind::Overlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("").unwrap(),
repeat: Some(PageRange::parse("1-2").unwrap()),
};
let mut specs = [spec];
let report = overlay_verbose_report(&mut dest, &mut specs).unwrap();
let src_pages: Vec<u32> = report.iter().map(|p| p.sources[0].src_page).collect();
assert_eq!(src_pages, vec![1, 2, 1, 2, 1]);
}
#[test]
fn overlay_verbose_report_empty_to_yields_all_empty_entries() {
let mut dest = open(n_page_doc(3));
let spec = OverlaySpec {
source: open(n_page_doc(2)),
kind: OverlayKind::Overlay,
from: PageRange::parse("").unwrap(),
to: PageRange::empty(),
repeat: None,
};
let mut specs = [spec];
let report = overlay_verbose_report(&mut dest, &mut specs).unwrap();
assert_eq!(report.len(), 3);
for (i, page) in report.iter().enumerate() {
assert_eq!(page.dest_page, (i + 1) as u32);
assert!(page.sources.is_empty());
}
}
#[test]
fn overlay_verbose_report_does_not_mutate_dest() {
let mut dest = open(n_page_doc(3));
let page_refs_before = page_refs(&mut dest).unwrap();
assert_eq!(page_refs_before.len(), 3);
let page1_ref = page_refs_before[0];
let dict_before = page_dictionary(&mut dest, page1_ref).unwrap();
let spec = OverlaySpec {
source: open(n_page_doc(1)),
kind: OverlayKind::Overlay,
from: PageRange::parse("").unwrap(),
to: PageRange::parse("").unwrap(),
repeat: None,
};
let mut specs = [spec];
let _ = overlay_verbose_report(&mut dest, &mut specs).unwrap();
let page_refs_after = page_refs(&mut dest).unwrap();
assert_eq!(page_refs_before, page_refs_after);
let dict_after = page_dictionary(&mut dest, page1_ref).unwrap();
assert_eq!(dict_before.get("Contents"), dict_after.get("Contents"));
assert_eq!(dict_before.get("Resources"), dict_after.get("Resources"));
}
#[test]
fn overlay_verbose_report_propagates_spec_page_resolution_error() {
let mut dest = open(n_page_doc(2));
let mut specs = [OverlaySpec {
source: open(n_page_doc(1)),
kind: OverlayKind::Overlay,
from: PageRange::parse("2").unwrap(),
to: PageRange::parse("").unwrap(),
repeat: None,
}];
let result = overlay_verbose_report(&mut dest, &mut specs);
assert!(
matches!(result, Err(Error::Parse { .. })),
"out-of-range --from should propagate as Err(Parse), got {result:?}"
);
}
}