#![cfg(feature = "qpdf-zlib-compat")]
mod common;
use common::PdfCanonicalTestExt;
use common::{write_with_settings, WriterTestSettings};
use flpdf::{load_xref_and_trailer, ObjectRef, ObjectStreamMode, Pdf, StreamDataMode, XrefEntry};
use std::io::Cursor;
use std::path::Path;
fn rewrite_qpdf_equivalent(fixture: &str) -> Vec<u8> {
rewrite_qpdf_equivalent_mode(fixture, ObjectStreamMode::Disable)
}
fn rewrite_qpdf_equivalent_mode(fixture: &str, mode: ObjectStreamMode) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
let mut pdf = Pdf::open(std::io::BufReader::new(file)).unwrap();
let opts = WriterTestSettings {
object_streams: mode,
static_id: true,
newline_before_endstream: flpdf::NewlineBeforeEndstream::Never,
..WriterTestSettings::default()
};
let mut out = Vec::new();
write_with_settings(&mut pdf, &mut out, &opts).unwrap();
out
}
fn golden(fixture_stem: &str) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/golden/references")
.join(fixture_stem)
.join("static-id.pdf");
std::fs::read(&path).unwrap_or_else(|e| panic!("read golden {path:?}: {e}"))
}
fn first_diff(a: &[u8], b: &[u8]) -> Option<usize> {
if a == b {
return None;
}
let common = a.len().min(b.len());
for i in 0..common {
if a[i] != b[i] {
return Some(i);
}
}
Some(common)
}
fn assert_cmp_diff_zero(fixture: &str, stem: &str) {
let actual = rewrite_qpdf_equivalent(fixture);
let expected = golden(stem);
if let Some(off) = first_diff(&actual, &expected) {
let lo = off.saturating_sub(16);
panic!(
"{fixture}: not byte-identical to qpdf --static-id golden \
(flpdf={} bytes, golden={} bytes, first diff at byte {off})\n\
flpdf : {:?}\ngolden: {:?}",
actual.len(),
expected.len(),
&actual[lo..(off + 16).min(actual.len())],
&expected[lo..(off + 16).min(expected.len())],
);
}
}
fn assert_cmp_diff_zero_mode_named(fixture: &str, mode: ObjectStreamMode, stem: &str, name: &str) {
let actual = rewrite_qpdf_equivalent_mode(fixture, mode);
assert_cmp_diff_zero_named(&actual, stem, name);
}
fn assert_mode_cmp_diff_zero(fixture: &str, mode: ObjectStreamMode) {
assert_cmp_diff_zero_mode_named(&format!("{fixture}.pdf"), mode, fixture, "static-id.pdf");
}
fn rewrite_mode_force_qpdf_equivalent(
fixture: &str,
mode: ObjectStreamMode,
force: &str,
) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
let mut pdf = Pdf::open(std::io::BufReader::new(file)).unwrap();
let opts = WriterTestSettings {
object_streams: mode,
force_version: Some(force.to_string()),
static_id: true,
newline_before_endstream: flpdf::NewlineBeforeEndstream::Never,
..WriterTestSettings::default()
};
let mut out = Vec::new();
write_with_settings(&mut pdf, &mut out, &opts).unwrap();
out
}
fn golden_named(stem: &str, name: &str) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/golden/references")
.join(stem)
.join(name);
std::fs::read(&path).unwrap_or_else(|e| panic!("read golden {path:?}: {e}"))
}
fn rewrite_preserve_qpdf_equivalent(fixture: &str) -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let file = std::fs::File::open(&path).unwrap_or_else(|e| panic!("open {path:?}: {e}"));
let mut pdf = Pdf::open(std::io::BufReader::new(file)).unwrap();
let opts = WriterTestSettings {
static_id: true,
stream_data: Some(StreamDataMode::Preserve),
newline_before_endstream: flpdf::NewlineBeforeEndstream::Never,
..WriterTestSettings::default()
};
let mut out = Vec::new();
write_with_settings(&mut pdf, &mut out, &opts).unwrap();
out
}
fn assert_cmp_diff_zero_named(actual: &[u8], stem: &str, name: &str) {
let expected = golden_named(stem, name);
if let Some(off) = first_diff(actual, &expected) {
let lo = off.saturating_sub(16);
panic!(
"{stem}/{name}: not byte-identical to qpdf golden \
(flpdf={} bytes, golden={} bytes, first diff at byte {off})\n\
flpdf : {:?}\ngolden: {:?}",
actual.len(),
expected.len(),
&actual[lo..(off + 16).min(actual.len())],
&expected[lo..(off + 16).min(expected.len())],
);
}
}
#[test]
fn force_below_1_5_downgrades_xref_stream_source_byte_identical_to_qpdf() {
let actual = rewrite_mode_force_qpdf_equivalent(
"three-page-objstm.pdf",
ObjectStreamMode::Preserve,
"1.4",
);
let expected = golden_named("three-page-objstm", "downgrade-force14.pdf");
if let Some(off) = first_diff(&actual, &expected) {
let lo = off.saturating_sub(16);
panic!(
"xref-stream downgrade not byte-identical to qpdf golden \
(flpdf={} bytes, golden={} bytes, first diff at byte {off})\n\
flpdf : {:?}\ngolden: {:?}",
actual.len(),
expected.len(),
&actual[lo..(off + 16).min(actual.len())],
&expected[lo..(off + 16).min(expected.len())],
);
}
}
#[test]
fn one_two_three_page_mode_matrix_is_byte_identical_to_qpdf() {
for fixture in ["one-page", "two-page", "three-page"] {
for mode in [ObjectStreamMode::Disable, ObjectStreamMode::Preserve] {
assert_mode_cmp_diff_zero(fixture, mode);
}
}
}
#[test]
fn disable_xref_stream_source_downgrades_to_classic_table_byte_identical_to_qpdf() {
assert_cmp_diff_zero_mode_named(
"null-visible-matrix-objstm.pdf",
ObjectStreamMode::Disable,
"null-visible-matrix-objstm",
"disable.pdf",
);
}
#[test]
fn preserve_object_stream_mode_is_byte_identical_to_qpdf_static_id_matrix() {
let cases = [
("three-page-objstm.pdf", "three-page-objstm", "preserve.pdf"),
(
"objstm-lin-od-indirect-length.pdf",
"objstm-lin-od-indirect-length",
"static-id.pdf",
),
(
"objstm-lin-od-indirect-length-flate.pdf",
"objstm-lin-od-indirect-length-flate",
"static-id.pdf",
),
(
"kept-indirect-length.pdf",
"kept-indirect-length",
"static-id.pdf",
),
];
for (fixture, stem, name) in cases {
assert_cmp_diff_zero_mode_named(fixture, ObjectStreamMode::Preserve, stem, name);
}
}
#[test]
fn preserve_nonmonotonic_source_indices_match_qpdf_source_number_order() {
let fixture = "nonmonotonic-objstm-index.pdf";
let path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let source = std::fs::read(path).unwrap();
let source_xref = load_xref_and_trailer(&mut Cursor::new(&source)).unwrap();
assert_eq!(
source_xref.entries.get(&ObjectRef::new(3, 0)),
Some(&XrefEntry::Compressed {
stream: 4,
index: 0,
})
);
assert_eq!(
source_xref.entries.get(&ObjectRef::new(2, 0)),
Some(&XrefEntry::Compressed {
stream: 4,
index: 1,
})
);
let actual = rewrite_qpdf_equivalent_mode(fixture, ObjectStreamMode::Preserve);
assert_cmp_diff_zero_named(&actual, "nonmonotonic-objstm-index", "preserve.pdf");
let output_xref = load_xref_and_trailer(&mut Cursor::new(&actual)).unwrap();
assert_eq!(
output_xref.entries.get(&ObjectRef::new(3, 0)),
Some(&XrefEntry::Compressed {
stream: 2,
index: 0,
})
);
assert_eq!(
output_xref.entries.get(&ObjectRef::new(4, 0)),
Some(&XrefEntry::Compressed {
stream: 2,
index: 1,
})
);
let mut rewritten = Pdf::open(Cursor::new(actual)).unwrap();
let catalog = rewritten
.resolve_canonical_object(rewritten.root_ref().unwrap())
.unwrap();
assert_eq!(
catalog.try_get_key(b"/Pages").unwrap().object_ref(),
Some(ObjectRef::new(3, 0))
);
assert_eq!(
catalog.try_get_key(b"/Extra").unwrap().object_ref(),
Some(ObjectRef::new(4, 0))
);
}
#[test]
fn lone_flate_l9_plain_rewrite_is_byte_identical_to_qpdf_static_id() {
assert_cmp_diff_zero("lone-flate-l9.pdf", "lone-flate-l9");
}
#[test]
fn od_indirect_length_plain_rewrite_drops_orphan_holder_byte_identical_to_qpdf() {
assert_cmp_diff_zero(
"objstm-lin-od-indirect-length.pdf",
"objstm-lin-od-indirect-length",
);
}
#[test]
fn od_indirect_length_flate_plain_rewrite_drops_orphan_holder_byte_identical_to_qpdf() {
assert_cmp_diff_zero(
"objstm-lin-od-indirect-length-flate.pdf",
"objstm-lin-od-indirect-length-flate",
);
}
#[test]
fn od_indirect_length_preserve_drops_orphan_holder_byte_identical_to_qpdf() {
let actual = rewrite_preserve_qpdf_equivalent("objstm-lin-od-indirect-length.pdf");
assert_cmp_diff_zero_named(&actual, "objstm-lin-od-indirect-length", "preserve.pdf");
}
#[test]
fn od_indirect_length_flate_preserve_drops_orphan_holder_byte_identical_to_qpdf() {
let actual = rewrite_preserve_qpdf_equivalent("objstm-lin-od-indirect-length-flate.pdf");
assert_cmp_diff_zero_named(
&actual,
"objstm-lin-od-indirect-length-flate",
"preserve.pdf",
);
}
#[test]
fn kept_indirect_length_preserve_directizes_kept_holder_byte_identical_to_qpdf() {
let actual = rewrite_preserve_qpdf_equivalent("kept-indirect-length.pdf");
assert_cmp_diff_zero_named(&actual, "kept-indirect-length", "preserve.pdf");
}
#[test]
fn kept_indirect_length_plain_rewrite_directizes_length_keeps_holder_byte_identical_to_qpdf() {
assert_cmp_diff_zero("kept-indirect-length.pdf", "kept-indirect-length");
}