#![cfg(feature = "qpdf-zlib-compat")]
mod common;
use common::PdfCanonicalTestExt;
use common::{write_with_settings, WriterTestSettings};
use flpdf::{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 catalog_metadata_observation(bytes: &[u8]) -> (Option<ObjectRef>, Vec<u8>, Vec<u8>) {
let mut pdf = Pdf::open(std::io::Cursor::new(bytes.to_vec())).expect("open metadata PDF");
let metadata = pdf
.root_handle()
.expect("catalog handle")
.try_get_key(b"/Metadata")
.expect("catalog Metadata key");
let object_ref = metadata.object_ref();
let dictionary = metadata
.try_get_stream_dict()
.expect("metadata stream dictionary");
let filter = dictionary
.try_get_key(b"/Filter")
.expect("metadata Filter lookup")
.unparse();
let packet = metadata
.get_stream_data(flpdf::writer::DecodeLevel::All)
.expect("decode XMP metadata packet");
(object_ref, filter, packet.as_ref().clone())
}
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())],
);
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct PdfaSnapshot {
language: Vec<u8>,
mark_info: Vec<u8>,
metadata_ref_valid: bool,
metadata_filter: Vec<u8>,
metadata_packet: Vec<u8>,
output_intent_subtype: Vec<u8>,
profile_ref_valid: bool,
profile_n: Vec<u8>,
profile_filter: Vec<u8>,
icc_payload: Vec<u8>,
struct_tree_ref_valid: bool,
struct_element_ref_valid: bool,
parent_tree_ref_valid: bool,
associated_file: Option<(Vec<u8>, bool, Vec<u8>)>,
}
fn pdfa_snapshot(bytes: &[u8]) -> PdfaSnapshot {
let mut pdf = Pdf::open(std::io::Cursor::new(bytes.to_vec())).expect("open PDF/A fixture");
let catalog = pdf.root_handle().expect("catalog handle");
let language = catalog
.try_get_key(b"/Lang")
.expect("catalog Lang")
.unparse();
let mark_info = catalog
.try_get_key(b"/MarkInfo")
.expect("catalog MarkInfo")
.unparse();
let metadata = catalog.try_get_key(b"/Metadata").expect("catalog Metadata");
let metadata_ref_valid = metadata.object_ref().is_some();
let metadata_dict = metadata
.try_get_stream_dict()
.expect("Metadata stream dictionary");
let metadata_filter = metadata_dict
.try_get_key(b"/Filter")
.expect("Metadata Filter")
.unparse();
let metadata_packet = metadata
.get_stream_data(flpdf::writer::DecodeLevel::All)
.expect("decode XMP packet")
.as_ref()
.clone();
let output_intents = catalog
.try_get_key(b"/OutputIntents")
.expect("catalog OutputIntents");
let output_intent = output_intents
.try_get_array_item(0)
.expect("first OutputIntent");
let output_intent_subtype = output_intent
.try_get_key(b"/S")
.expect("OutputIntent subtype")
.unparse();
let profile = output_intent
.try_get_key(b"/DestOutputProfile")
.expect("DestOutputProfile stream");
let profile_ref_valid = profile.object_ref().is_some();
let profile_dict = profile
.try_get_stream_dict()
.expect("ICC profile dictionary");
let profile_n = profile_dict
.try_get_key(b"/N")
.expect("ICC component count")
.unparse();
let profile_filter = profile_dict
.try_get_key(b"/Filter")
.expect("ICC profile Filter")
.unparse();
let icc_payload = profile
.get_stream_data(flpdf::writer::DecodeLevel::All)
.expect("decode ICC profile")
.as_ref()
.clone();
let struct_tree = catalog
.try_get_key(b"/StructTreeRoot")
.expect("catalog StructTreeRoot");
let struct_tree_ref_valid = struct_tree.object_ref().is_some();
let struct_element_ref_valid = struct_tree
.try_get_key(b"/K")
.expect("StructTreeRoot K")
.object_ref()
.is_some();
let parent_tree_ref_valid = struct_tree
.try_get_key(b"/ParentTree")
.expect("StructTreeRoot ParentTree")
.object_ref()
.is_some();
let associated_files = catalog.try_get_key(b"/AF").expect("catalog AF lookup");
let associated_file = if associated_files.try_is_null().expect("AF type") {
None
} else {
let filespec = associated_files
.try_get_array_item(0)
.expect("first associated Filespec");
let relationship = filespec
.try_get_key(b"/AFRelationship")
.expect("Filespec AFRelationship")
.unparse();
let embedded_file = filespec
.try_get_key(b"/EF")
.expect("Filespec EF")
.try_get_key(b"/F")
.expect("embedded file stream");
let embedded_file_ref_valid = embedded_file.object_ref().is_some();
let embedded_file_payload = embedded_file
.get_stream_data(flpdf::writer::DecodeLevel::All)
.expect("read associated-file payload")
.as_ref()
.clone();
Some((relationship, embedded_file_ref_valid, embedded_file_payload))
};
PdfaSnapshot {
language,
mark_info,
metadata_ref_valid,
metadata_filter,
metadata_packet,
output_intent_subtype,
profile_ref_valid,
profile_n,
profile_filter,
icc_payload,
struct_tree_ref_valid,
struct_element_ref_valid,
parent_tree_ref_valid,
associated_file,
}
}
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 compressed_metadata_xmp_rewrite_matches_qpdf_and_preserves_decoded_packet() {
let fixture_path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/compressed-metadata.pdf");
let input = std::fs::read(&fixture_path).expect("read compressed metadata fixture");
let (input_ref, input_filter, input_packet) = catalog_metadata_observation(&input);
assert!(
input_ref.is_some(),
"input /Metadata reference must be indirect"
);
assert_eq!(input_filter, b"/FlateDecode");
let actual = rewrite_qpdf_equivalent("compressed-metadata.pdf");
assert_cmp_diff_zero_named(&actual, "compressed-metadata", "static-id.pdf");
let (output_ref, output_filter, output_packet) = catalog_metadata_observation(&actual);
assert!(
output_ref.is_some(),
"output /Metadata reference must remain valid"
);
assert_eq!(
output_filter, b"null",
"qpdf removes the source filter for clear XMP"
);
assert_eq!(
output_packet, input_packet,
"decoded XMP packet bytes must survive"
);
}
#[test]
fn pdfa_part_fixtures_round_trip_like_qpdf() {
for (part, fixture, stem) in [
(1, "pdfa-1b.pdf", "pdfa-1b"),
(2, "pdfa-2b.pdf", "pdfa-2b"),
(3, "pdfa-3b.pdf", "pdfa-3b"),
] {
let input_path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let input = std::fs::read(&input_path)
.unwrap_or_else(|error| panic!("read {input_path:?}: {error}"));
let before = pdfa_snapshot(&input);
assert!(
before.metadata_ref_valid,
"PDF/A-{part}b Metadata reference"
);
assert!(before.profile_ref_valid, "PDF/A-{part}b ICC reference");
assert!(
before.struct_tree_ref_valid,
"PDF/A-{part}b StructTreeRoot reference"
);
assert!(
before.struct_element_ref_valid,
"PDF/A-{part}b StructElem reference"
);
assert!(
before.parent_tree_ref_valid,
"PDF/A-{part}b ParentTree reference"
);
let marker = format!("pdfaid:part=\"{part}\"");
assert!(
before
.metadata_packet
.windows(marker.len())
.any(|window| window == marker.as_bytes()),
"XMP must identify PDF/A part {part}"
);
assert_eq!(before.metadata_filter, b"/FlateDecode");
assert_eq!(before.profile_filter, b"null");
assert_eq!(before.associated_file.is_some(), part == 3);
let mut expected_after = before.clone();
expected_after.metadata_filter = b"null".to_vec();
expected_after.profile_filter = b"/FlateDecode".to_vec();
let actual = rewrite_qpdf_equivalent(fixture);
assert_cmp_diff_zero_named(&actual, stem, "static-id.pdf");
assert_eq!(
pdfa_snapshot(&actual),
expected_after,
"decoded PDF/A-{part}b payloads and references must survive qpdf-equivalent rewrite"
);
}
}
#[test]
fn direct_root_survives_a_preserve_cross_reference_stream() {
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable");
return;
};
let directory = tempfile::tempdir().expect("tempdir");
let input = directory.path().join("direct-root-objstm.pdf");
std::fs::write(&input, direct_root_object_stream_pdf()).expect("write fixture");
let expected_path = directory.path().join("qpdf.pdf");
let status = std::process::Command::new(oracle)
.args(["--deterministic-id", "--object-streams=preserve"])
.arg(&input)
.arg(&expected_path)
.status()
.expect("qpdf runs");
assert!(
status.success(),
"qpdf must rewrite the direct-root fixture"
);
let file = std::fs::File::open(&input).expect("open fixture");
let mut pdf = Pdf::open(std::io::BufReader::new(file)).expect("fixture parses");
let opts = WriterTestSettings {
object_streams: ObjectStreamMode::Preserve,
deterministic_id: true,
newline_before_endstream: flpdf::NewlineBeforeEndstream::Never,
..WriterTestSettings::default()
};
let mut actual = Vec::new();
write_with_settings(&mut pdf, &mut actual, &opts).expect("rewrite succeeds");
let expected = std::fs::read(&expected_path).expect("qpdf output");
if let Some(off) = first_diff(&actual, &expected) {
panic!(
"direct-root Preserve output diverged from qpdf 11.9.0 \
(flpdf={} bytes, qpdf={} bytes, first diff at byte {off})",
actual.len(),
expected.len(),
);
}
}
fn direct_root_object_stream_pdf() -> Vec<u8> {
fn deflate(data: &[u8]) -> Vec<u8> {
use std::io::Write;
let mut encoder =
flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
encoder.write_all(data).expect("deflate write");
encoder.finish().expect("deflate finish")
}
let member = b"<< /Type /Metadata /Note (in-objstm) >>";
let first = b"5 0 ";
let mut objstm_data = first.to_vec();
objstm_data.extend_from_slice(member);
let mut out = b"%PDF-1.5\n%\xe2\xe3\xcf\xd3\n".to_vec();
let mut offsets = std::collections::BTreeMap::new();
let bodies: [(u32, Vec<u8>); 2] = [
(2, b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec()),
(
3,
b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Resources << >> /Meta 5 0 R >>"
.to_vec(),
),
];
for (number, body) in bodies {
offsets.insert(number, out.len());
out.extend_from_slice(format!("{number} 0 obj\n").as_bytes());
out.extend_from_slice(&body);
out.extend_from_slice(b"\nendobj\n");
}
offsets.insert(4, out.len());
out.extend_from_slice(
format!(
"4 0 obj\n<< /Type /ObjStm /N 1 /First {} /Length {} >>\nstream\n",
first.len(),
objstm_data.len()
)
.as_bytes(),
);
out.extend_from_slice(&objstm_data);
out.extend_from_slice(b"\nendstream\nendobj\n");
let xref_offset = out.len();
let mut rows: Vec<[u8; 7]> = Vec::new();
let row = |kind: u8, field2: u32, field3: u16| {
let mut entry = [0u8; 7];
entry[0] = kind;
entry[1..5].copy_from_slice(&field2.to_be_bytes());
entry[5..7].copy_from_slice(&field3.to_be_bytes());
entry
};
rows.push(row(0, 0, 65535));
rows.push(row(0, 0, 65535));
for number in [2u32, 3, 4] {
rows.push(row(1, offsets[&number] as u32, 0));
}
rows.push(row(2, 4, 0));
rows.push(row(1, xref_offset as u32, 0));
let table: Vec<u8> = rows.concat();
let compressed = deflate(&table);
out.extend_from_slice(
format!(
"6 0 obj\n<< /Type /XRef /Size 7 /W [1 4 2] \
/Root << /Type /Catalog /Pages 2 0 R >> /Filter /FlateDecode /Length {} >>\nstream\n",
compressed.len()
)
.as_bytes(),
);
out.extend_from_slice(&compressed);
out.extend_from_slice(b"\nendstream\nendobj\n");
out.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
out
}
#[test]
fn preserve_unreferenced_with_source_object_streams_matches_qpdf_11_9() {
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable");
return;
};
let directory = tempfile::tempdir().expect("tempdir");
for fixture in [
"null-visible-matrix-objstm.pdf",
"null-visible-preserve-empty-removed.pdf",
"null-visible-stale-generation-objstm.pdf",
"null-visible-preserve-signature.pdf",
"three-page-objstm.pdf",
"shared-stream-objstm.pdf",
] {
let input = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let expected_path = directory.path().join(format!("{fixture}.qpdf"));
let status = std::process::Command::new(oracle)
.args([
"--deterministic-id",
"--object-streams=preserve",
"--preserve-unreferenced",
])
.arg(&input)
.arg(&expected_path)
.status()
.expect("qpdf runs");
assert!(
matches!(status.code(), Some(0 | 3)),
"{fixture}: qpdf --preserve-unreferenced must produce output, got {:?}",
status.code()
);
let actual = rewrite_qpdf_equivalent_preserve_unreferenced(fixture);
let expected = std::fs::read(&expected_path).expect("qpdf output");
if let Some(off) = first_diff(&actual, &expected) {
panic!(
"{fixture}: --preserve-unreferenced output diverged from qpdf 11.9.0 \
(flpdf={} bytes, qpdf={} bytes, first diff at byte {off})",
actual.len(),
expected.len(),
);
}
}
}
#[test]
fn qdf_preserve_unreferenced_signature_objstm_matches_qpdf_11_9() {
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable");
return;
};
let directory = tempfile::tempdir().expect("tempdir");
for fixture in [
"null-visible-preserve-signature.pdf",
"null-visible-preserve-empty-removed.pdf",
"null-visible-stale-generation-objstm.pdf",
"trailer-external-file-keys.pdf",
] {
let input = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let expected_path = directory.path().join(format!("{fixture}.qpdf"));
let status = std::process::Command::new(oracle)
.args(["--static-id", "--qdf", "--preserve-unreferenced"])
.arg(&input)
.arg(&expected_path)
.status()
.expect("qpdf runs");
if fixture == "null-visible-preserve-signature.pdf" {
assert_eq!(
status.code(),
Some(0),
"{fixture}: qpdf signature rewrite must succeed without warnings"
);
}
assert!(
matches!(status.code(), Some(0 | 3)),
"{fixture}: qpdf --qdf --preserve-unreferenced must produce output, got {:?}",
status.code()
);
let actual = rewrite_qdf_preserve_unreferenced(fixture).unwrap_or_else(|error| {
panic!("{fixture}: flpdf --qdf --preserve-unreferenced must succeed like qpdf: {error}")
});
let expected = std::fs::read(&expected_path).expect("qpdf output");
if let Some(off) = first_diff(&actual, &expected) {
panic!(
"{fixture}: --qdf --preserve-unreferenced output diverged from qpdf 11.9.0 \
(flpdf={} bytes, qpdf={} bytes, first diff at byte {off})",
actual.len(),
expected.len(),
);
}
}
}
#[test]
fn preserve_external_file_stream_matches_qpdf_11_9() {
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable");
return;
};
let input = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/external-file-stream.pdf");
let directory = tempfile::tempdir().expect("tempdir");
let expected_path = directory.path().join("qpdf.pdf");
let status = std::process::Command::new(oracle)
.args(["--static-id", "--stream-data=preserve"])
.arg(&input)
.arg(&expected_path)
.status()
.expect("qpdf runs");
assert!(
matches!(status.code(), Some(0 | 3)),
"qpdf preserve rewrite must produce output, got {:?}",
status.code()
);
let actual = rewrite_preserve_qpdf_equivalent("external-file-stream.pdf");
let expected = std::fs::read(&expected_path).expect("qpdf output");
if let Some(off) = first_diff(&actual, &expected) {
let lo = off.saturating_sub(16);
panic!(
"external-file stream preserve output diverged from qpdf 11.9.0 \
(flpdf={} bytes, qpdf={} bytes, first diff at byte {off})\n\
flpdf : {:?}\nqpdf : {:?}",
actual.len(),
expected.len(),
&actual[lo..(off + 16).min(actual.len())],
&expected[lo..(off + 16).min(expected.len())],
);
}
}
#[test]
fn trailer_external_file_keys_match_qpdf_11_9() {
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable");
return;
};
let fixture = "trailer-external-file-keys.pdf";
let input = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let directory = tempfile::tempdir().expect("tempdir");
let expected_path = directory.path().join("qpdf.pdf");
let status = std::process::Command::new(oracle)
.args(["--static-id"])
.arg(&input)
.arg(&expected_path)
.status()
.expect("qpdf runs");
assert_eq!(status.code(), Some(0), "qpdf rewrite must succeed");
let actual = rewrite_qpdf_equivalent(fixture);
let expected = std::fs::read(&expected_path).expect("qpdf output");
assert_eq!(
actual, expected,
"trailer external-file keys must match qpdf"
);
let mut output = Pdf::open(Cursor::new(actual)).expect("open rewritten output");
let trailer = output.trailer();
assert_eq!(trailer.try_get_key(b"/F").unwrap().unparse(), b"2 0 R");
assert_eq!(
trailer.try_get_key(b"/FFilter").unwrap().unparse(),
b"/ASCIIHexDecode"
);
assert_eq!(
trailer.try_get_key(b"/FDecodeParms").unwrap().unparse(),
b"<< /Columns 1 >>"
);
}
#[test]
fn trailer_external_file_keys_generate_match_qpdf_11_9() {
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable");
return;
};
let fixture = "trailer-external-file-keys.pdf";
let input = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let directory = tempfile::tempdir().expect("tempdir");
let expected_path = directory.path().join("qpdf.pdf");
let status = std::process::Command::new(oracle)
.args(["--static-id", "--object-streams=generate"])
.arg(&input)
.arg(&expected_path)
.status()
.expect("qpdf runs");
assert_eq!(status.code(), Some(0), "qpdf generate rewrite must succeed");
let actual = rewrite_qpdf_equivalent_mode(fixture, ObjectStreamMode::Generate);
let expected = std::fs::read(&expected_path).expect("qpdf output");
assert_eq!(
actual, expected,
"Generate must retain trailer external-file keys like qpdf"
);
}
fn pinned_qpdf() -> Option<&'static str> {
let output = std::process::Command::new("qpdf").arg("--version").output();
output.ok().and_then(|output| {
String::from_utf8_lossy(&output.stdout)
.lines()
.next()
.is_some_and(|line| line == "qpdf version 11.9.0")
.then_some("qpdf")
})
}
fn rewrite_qpdf_equivalent_preserve_unreferenced(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 {
object_streams: ObjectStreamMode::Preserve,
deterministic_id: true,
preserve_unreferenced_objects: 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 rewrite_qdf_preserve_unreferenced(fixture: &str) -> flpdf::Result<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))?;
let opts = WriterTestSettings {
object_streams: ObjectStreamMode::Preserve,
qdf: true,
static_id: true,
preserve_unreferenced_objects: true,
newline_before_endstream: flpdf::NewlineBeforeEndstream::Never,
..WriterTestSettings::default()
};
let mut out = Vec::new();
write_with_settings(&mut pdf, &mut out, &opts)?;
Ok(out)
}
#[test]
fn preserve_with_no_source_object_streams_matches_disable_byte_for_byte() {
for fixture in [
"one-page",
"two-page",
"three-page",
"preserve-no-source-objstm-xref",
] {
let disable =
rewrite_qpdf_equivalent_mode(&format!("{fixture}.pdf"), ObjectStreamMode::Disable);
let preserve =
rewrite_qpdf_equivalent_mode(&format!("{fixture}.pdf"), ObjectStreamMode::Preserve);
assert_eq!(
disable, preserve,
"{fixture}: Preserve-with-no-source-ObjStm diverged from Disable"
);
}
}
#[test]
fn preserve_no_source_objstm_xref_stream_matches_qpdf_11_9() {
let fixture = "preserve-no-source-objstm-xref.pdf";
let fixture_path = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat")
.join(fixture);
let source = std::fs::read(&fixture_path).expect("fixture is readable");
let startxref = source
.windows(b"startxref".len())
.rposition(|window| window == b"startxref")
.expect("fixture has a startxref");
let offset: usize = String::from_utf8_lossy(&source[startxref + b"startxref".len()..])
.split_whitespace()
.next()
.expect("startxref carries an offset")
.parse()
.expect("startxref offset is numeric");
assert!(
!source[offset..].starts_with(b"xref"),
"the fixture's last cross-reference section must be a stream, not a classic table"
);
let source_pdf = Pdf::open(std::io::Cursor::new(source)).expect("fixture opens");
assert!(
source_pdf
.get_xref_table()
.values()
.all(|entry| !matches!(entry, XrefEntry::Compressed { .. })),
"the fixture must have no type-2 rows, or it is no longer the empty-membership case"
);
let preserve = rewrite_qpdf_equivalent_mode(fixture, ObjectStreamMode::Preserve);
let disable = rewrite_qpdf_equivalent_mode(fixture, ObjectStreamMode::Disable);
assert_eq!(
preserve, disable,
"empty source membership must produce the Disable-equivalent bytes"
);
assert!(
preserve
.windows(b"\nxref\n0 ".len())
.any(|window| window == b"\nxref\n0 "),
"an empty source membership must use a classic xref table"
);
assert!(
!preserve
.windows(b"/Type /XRef".len())
.any(|window| window == b"/Type /XRef"),
"the source xref stream must not be carried into the rewritten output"
);
let Some(oracle) = pinned_qpdf() else {
eprintln!("[SKIP cmp_diff_zero_tests] qpdf 11.9.0 is unavailable for the byte comparison");
return;
};
let directory = tempfile::tempdir().expect("tempdir");
let expected_path = directory.path().join("qpdf.pdf");
let status = std::process::Command::new(oracle)
.args(["--static-id", "--object-streams=preserve"])
.arg(&fixture_path)
.arg(&expected_path)
.status()
.expect("qpdf runs");
assert_eq!(status.code(), Some(0), "qpdf preserve rewrite must succeed");
let expected = std::fs::read(&expected_path).expect("qpdf output");
assert_eq!(preserve, expected, "Preserve output must match qpdf 11.9.0");
}
#[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_pdf = Pdf::open(Cursor::new(source)).unwrap();
let source_xref = source_pdf.get_xref_table();
assert_eq!(
source_xref.get(&ObjectRef::new(3, 0)),
Some(&XrefEntry::Compressed {
stream: 4,
index: 0,
})
);
assert_eq!(
source_xref.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_pdf = Pdf::open(Cursor::new(actual.clone())).unwrap();
let output_xref = output_pdf.get_xref_table();
assert_eq!(
output_xref.get(&ObjectRef::new(3, 0)),
Some(&XrefEntry::Compressed {
stream: 2,
index: 0,
})
);
assert_eq!(
output_xref.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");
}