use assert_cmd::Command as CargoCommand;
use flpdf::{
filters::decode_stream_data,
normalize_content_stream,
pages::{page_content_bytes, page_refs},
ContentStreamParser, ContentToken, Object, Pdf,
};
use std::io::Cursor;
use std::path::{Path, PathBuf};
use std::process::Command as ShellCommand;
use tempfile::tempdir;
const COMPAT_FIXTURE_DIR: &str = "../../tests/fixtures/compat";
fn fixture_path(name: &str) -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join(COMPAT_FIXTURE_DIR)
.join(name)
}
fn qpdf_available() -> bool {
ShellCommand::new("qpdf")
.arg("--version")
.output()
.map(|o| o.status.success())
.unwrap_or(false)
}
#[must_use]
fn skip_if_qpdf_missing() -> bool {
if qpdf_available() {
return false;
}
let on_ci = std::env::var_os("CI").is_some();
if on_ci {
panic!(
"qpdf is required for cli_optimization_matrix tests on CI; \
install qpdf in the workflow before running this test suite"
);
}
eprintln!(
"skipping qpdf --check guard: qpdf not available (target_os={}, CI={})",
std::env::consts::OS,
on_ci
);
true
}
fn run_rewrite(input: &Path, output: &Path, extra_args: &[&str]) {
let mut cmd = CargoCommand::cargo_bin("flpdf").expect("flpdf binary must exist");
cmd.arg("rewrite");
for &arg in extra_args {
cmd.arg(arg);
}
cmd.arg(input.to_str().unwrap());
cmd.arg(output.to_str().unwrap());
cmd.assert().success();
}
fn assert_qpdf_check(path: &Path) {
let out = ShellCommand::new("qpdf")
.arg("--check")
.arg(path.to_str().unwrap())
.output()
.expect("failed to spawn qpdf --check");
assert!(
out.status.success(),
"qpdf --check reported errors on {}:\nstdout: {}\nstderr: {}",
path.display(),
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr),
);
}
#[test]
fn normalize_content_y_produces_canonical_form() {
let tmp = tempdir().unwrap();
let input = fixture_path("one-page.pdf");
let output = tmp.path().join("normalized.pdf");
run_rewrite(
&input,
&output,
&["--full-rewrite", "--normalize-content=y"],
);
let input_bytes = std::fs::read(&input).unwrap();
let output_bytes = std::fs::read(&output).unwrap();
let mut in_pdf = Pdf::open(Cursor::new(input_bytes)).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(output_bytes)).unwrap();
let in_pages = page_refs(&mut in_pdf).unwrap();
let out_pages = page_refs(&mut out_pdf).unwrap();
assert_eq!(in_pages.len(), out_pages.len(), "page count must match");
for (in_pr, out_pr) in in_pages.iter().zip(out_pages.iter()) {
let in_content = page_content_bytes(&mut in_pdf, *in_pr).unwrap();
let out_content = page_content_bytes(&mut out_pdf, *out_pr).unwrap();
let expected = normalize_content_stream(&in_content)
.expect("normalize_content_stream must succeed on input");
assert_eq!(
out_content,
expected,
"normalize-content=y: decoded output content stream bytes do not equal \
normalize(input);\n\
output content (first 200 bytes): {:?}",
&out_content[..out_content.len().min(200)]
);
let normalized_out = normalize_content_stream(&out_content)
.expect("normalize_content_stream must succeed on output");
assert_eq!(
normalized_out, expected,
"normalize-content=y: output content stream is not idempotent under \
normalize_content_stream"
);
}
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn normalize_content_n_leaves_content_unchanged() {
let tmp = tempdir().unwrap();
let input = fixture_path("one-page.pdf");
let output = tmp.path().join("norm-n.pdf");
run_rewrite(
&input,
&output,
&["--full-rewrite", "--normalize-content=n"],
);
let input_bytes = std::fs::read(&input).unwrap();
let output_bytes = std::fs::read(&output).unwrap();
let mut in_pdf = Pdf::open(Cursor::new(input_bytes)).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(output_bytes)).unwrap();
let in_pages = page_refs(&mut in_pdf).unwrap();
let out_pages = page_refs(&mut out_pdf).unwrap();
for (in_pr, out_pr) in in_pages.iter().zip(out_pages.iter()) {
let in_content = page_content_bytes(&mut in_pdf, *in_pr).unwrap();
let out_content = page_content_bytes(&mut out_pdf, *out_pr).unwrap();
assert_eq!(
in_content, out_content,
"normalize-content=n: decoded content must be identical to input"
);
}
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn coalesce_contents_merges_array_to_single_stream() {
let tmp = tempdir().unwrap();
let input = fixture_path("multi-contents-one-page.pdf");
let output = tmp.path().join("coalesced.pdf");
run_rewrite(&input, &output, &["--full-rewrite", "--coalesce-contents"]);
let input_bytes = std::fs::read(&input).unwrap();
let output_bytes = std::fs::read(&output).unwrap();
let mut in_pdf = Pdf::open(Cursor::new(input_bytes)).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(output_bytes)).unwrap();
let out_pages = page_refs(&mut out_pdf).unwrap();
assert_eq!(out_pages.len(), 1, "output must have exactly one page");
let out_page_ref = out_pages[0];
let out_page_obj = out_pdf.resolve(out_page_ref).unwrap();
let out_page_dict = match &out_page_obj {
Object::Dictionary(d) => d.clone(),
other => panic!("page object must be a Dictionary, got {other:?}"),
};
let contents_entry = out_page_dict
.get("Contents")
.cloned()
.expect("/Contents must be present in output page");
assert!(
matches!(contents_entry, Object::Reference(_)),
"coalesce-contents: /Contents must be a single indirect reference after merge; \
got {contents_entry:?}"
);
let in_pages = page_refs(&mut in_pdf).unwrap();
assert_eq!(in_pages.len(), 1);
let in_content = page_content_bytes(&mut in_pdf, in_pages[0]).unwrap();
let out_content = page_content_bytes(&mut out_pdf, out_page_ref).unwrap();
let in_tokens = collect_content_tokens(&in_content);
let out_tokens = collect_content_tokens(&out_content);
assert_eq!(
in_tokens,
out_tokens,
"coalesce-contents: merged stream operator sequence must match concatenated inputs;\n\
input operators: {:?}\n\
output operators: {:?}",
&in_tokens[..in_tokens.len().min(10)],
&out_tokens[..out_tokens.len().min(10)],
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
fn collect_content_tokens(bytes: &[u8]) -> Vec<ContentToken> {
ContentStreamParser::new(bytes)
.map(|t| t.expect("content stream must parse successfully"))
.filter(|t| matches!(t, ContentToken::Op { .. }))
.collect()
}
#[test]
fn remove_unref_resources_auto_keeps_unused_font_like_qpdf() {
let tmp = tempdir().unwrap();
let input = fixture_path("unref-resources-one-page.pdf");
let output = tmp.path().join("unref-auto.pdf");
run_rewrite(
&input,
&output,
&["--full-rewrite", "--remove-unreferenced-resources=auto"],
);
let font_keys = extract_page_resource_keys(&output, "Font");
assert!(
font_keys.contains(&b"F1".to_vec()),
"remove-unreferenced-resources=auto: /F1 (used) must be retained; font keys: {:?}",
font_keys
);
assert!(
font_keys.contains(&b"F2".to_vec()),
"remove-unreferenced-resources=auto: /F2 (unused) must be retained on a plain \
rewrite (qpdf does not prune resource entries outside page operations); \
font keys: {:?}",
font_keys
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn remove_unref_resources_yes_keeps_unused_font_like_qpdf() {
let tmp = tempdir().unwrap();
let input = fixture_path("unref-resources-one-page.pdf");
let output = tmp.path().join("unref-yes.pdf");
run_rewrite(
&input,
&output,
&["--full-rewrite", "--remove-unreferenced-resources=yes"],
);
let font_keys = extract_page_resource_keys(&output, "Font");
assert!(
font_keys.contains(&b"F1".to_vec()),
"remove-unreferenced-resources=yes: /F1 (used) must be retained; font keys: {:?}",
font_keys
);
assert!(
font_keys.contains(&b"F2".to_vec()),
"remove-unreferenced-resources=yes: /F2 (unused) must be retained on a plain \
rewrite โ qpdf --remove-unreferenced-resources=yes also keeps it; font keys: {:?}",
font_keys
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn kept_indirect_length_plain_rewrite_keeps_image_xobject() {
let tmp = tempdir().unwrap();
let input = fixture_path("kept-indirect-length.pdf");
let output = tmp.path().join("kept-indirect-length-out.pdf");
run_rewrite(&input, &output, &["--static-id"]);
let xobject_keys = extract_page_resource_keys(&output, "XObject");
assert!(
xobject_keys.contains(&b"Im0".to_vec()),
"plain rewrite must keep the unreferenced image XObject /Im0 (qpdf keeps it); \
/Resources/XObject keys: {:?}",
xobject_keys
);
let out_bytes = std::fs::read(&output).unwrap();
assert!(
out_bytes.windows(9).any(|w| w == b"DCTDecode"),
"the DCTDecode image stream must survive the rewrite"
);
let output_fr = tmp.path().join("kept-indirect-length-fr.pdf");
run_rewrite(&input, &output_fr, &["--full-rewrite", "--static-id"]);
assert!(
extract_page_resource_keys(&output_fr, "XObject").contains(&b"Im0".to_vec()),
"--full-rewrite --static-id must also keep the image XObject /Im0",
);
}
#[test]
fn remove_unref_resources_no_retains_all_fonts() {
let tmp = tempdir().unwrap();
let input = fixture_path("unref-resources-one-page.pdf");
let output = tmp.path().join("unref-no.pdf");
run_rewrite(
&input,
&output,
&["--full-rewrite", "--remove-unreferenced-resources=no"],
);
let font_keys = extract_page_resource_keys(&output, "Font");
assert!(
font_keys.contains(&b"F1".to_vec()),
"remove-unreferenced-resources=no: /F1 must be retained; font keys: {:?}",
font_keys
);
assert!(
font_keys.contains(&b"F2".to_vec()),
"remove-unreferenced-resources=no: /F2 must be retained (no pruning); font keys: {:?}",
font_keys
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
fn extract_page_resource_keys(path: &Path, category: &str) -> Vec<Vec<u8>> {
let bytes = std::fs::read(path).unwrap();
let mut pdf = Pdf::open(Cursor::new(bytes)).unwrap();
let pages = page_refs(&mut pdf).unwrap();
assert!(!pages.is_empty(), "output PDF must have at least one page");
let page_ref = pages[0];
let page_obj = pdf.resolve(page_ref).unwrap();
let page_dict = match page_obj {
Object::Dictionary(d) => d,
other => panic!("page must be a Dictionary, got {other:?}"),
};
let resources_obj = match page_dict.get("Resources").cloned() {
Some(Object::Reference(r)) => pdf.resolve(r).unwrap(),
Some(obj) => obj,
None => return vec![],
};
let resources_dict = match resources_obj {
Object::Dictionary(d) => d,
_ => return vec![],
};
let cat_obj = match resources_dict.get(category).cloned() {
Some(Object::Reference(r)) => pdf.resolve(r).unwrap(),
Some(obj) => obj,
None => return vec![],
};
let cat_dict = match cat_obj {
Object::Dictionary(d) => d,
_ => return vec![],
};
cat_dict.iter().map(|(k, _)| k.to_vec()).collect()
}
#[test]
fn compress_streams_y_applies_flatedecode_and_roundtrips() {
let tmp = tempdir().unwrap();
let input = fixture_path("one-page.pdf");
let output = tmp.path().join("compress-y.pdf");
run_rewrite(&input, &output, &["--full-rewrite", "--compress-streams=y"]);
let output_bytes = std::fs::read(&output).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(&output_bytes)).unwrap();
let pages = page_refs(&mut out_pdf).unwrap();
assert!(!pages.is_empty());
for page_ref in &pages {
let page_obj = out_pdf.resolve(*page_ref).unwrap();
let page_dict = match &page_obj {
Object::Dictionary(d) => d.clone(),
other => panic!("page must be a Dictionary, got {other:?}"),
};
let contents_ref = match page_dict.get("Contents").cloned() {
Some(Object::Reference(r)) => r,
Some(other) => panic!("expected /Contents to be a reference, got {other:?}"),
None => continue, };
let content_stream = match out_pdf.resolve(contents_ref).unwrap() {
Object::Stream(s) => s,
other => panic!("expected /Contents to resolve to a Stream, got {other:?}"),
};
let filter = content_stream.dict.get("Filter").cloned();
let is_flatedecode = match &filter {
Some(Object::Name(n)) => n.as_slice() == b"FlateDecode",
Some(Object::Array(arr)) => {
matches!(arr.as_slice(), [Object::Name(n)] if n.as_slice() == b"FlateDecode")
}
_ => false,
};
assert!(
is_flatedecode,
"compress-streams=y: /Contents stream must have /Filter /FlateDecode; got {filter:?}"
);
let decoded = decode_stream_data(&content_stream.dict, &content_stream.data)
.expect("decoding FlateDecode stream must succeed");
assert!(
!decoded.is_empty(),
"compress-streams=y: decoded content stream must be non-empty"
);
}
let input_bytes = std::fs::read(&input).unwrap();
let mut in_pdf = Pdf::open(Cursor::new(input_bytes)).unwrap();
let in_pages = page_refs(&mut in_pdf).unwrap();
for (in_pr, out_pr) in in_pages.iter().zip(pages.iter()) {
let in_content = page_content_bytes(&mut in_pdf, *in_pr).unwrap();
let out_content = page_content_bytes(&mut out_pdf, *out_pr).unwrap();
assert_eq!(
in_content, out_content,
"compress-streams=y: decoded content round-trip must be byte-identical to input"
);
}
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn compress_streams_n_omits_filter_and_roundtrips() {
let tmp = tempdir().unwrap();
let input = fixture_path("one-page.pdf");
let output = tmp.path().join("compress-n.pdf");
run_rewrite(&input, &output, &["--full-rewrite", "--compress-streams=n"]);
let output_bytes = std::fs::read(&output).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(&output_bytes)).unwrap();
let pages = page_refs(&mut out_pdf).unwrap();
assert!(!pages.is_empty());
for page_ref in &pages {
let page_obj = out_pdf.resolve(*page_ref).unwrap();
let page_dict = match &page_obj {
Object::Dictionary(d) => d.clone(),
other => panic!("page must be a Dictionary, got {other:?}"),
};
let contents_ref = match page_dict.get("Contents").cloned() {
Some(Object::Reference(r)) => r,
Some(other) => panic!("expected /Contents reference, got {other:?}"),
None => continue,
};
let content_stream = match out_pdf.resolve(contents_ref).unwrap() {
Object::Stream(s) => s,
other => panic!("expected a Stream, got {other:?}"),
};
let filter = content_stream.dict.get("Filter");
assert!(
filter.is_none(),
"compress-streams=n: /Contents stream must have no /Filter key; got {filter:?}"
);
}
let input_bytes = std::fs::read(&input).unwrap();
let mut in_pdf = Pdf::open(Cursor::new(input_bytes)).unwrap();
let in_pages = page_refs(&mut in_pdf).unwrap();
for (in_pr, out_pr) in in_pages.iter().zip(pages.iter()) {
let in_content = page_content_bytes(&mut in_pdf, *in_pr).unwrap();
let out_content = page_content_bytes(&mut out_pdf, *out_pr).unwrap();
assert_eq!(
in_content, out_content,
"compress-streams=n: raw content must be byte-identical to decoded input"
);
}
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn newline_before_endstream_y_always_inserts_newline() {
let tmp = tempdir().unwrap();
let input = fixture_path("one-page.pdf");
let output = tmp.path().join("newline-y.pdf");
run_rewrite(
&input,
&output,
&["--full-rewrite", "--newline-before-endstream=y"],
);
let output_bytes = std::fs::read(&output).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(output_bytes.clone())).unwrap();
let endstream_offsets = real_endstream_offsets(&output_bytes, &mut out_pdf);
assert!(
!endstream_offsets.is_empty(),
"newline-before-endstream=y: no stream objects found in output"
);
let mut violations = 0usize;
for &start in &endstream_offsets {
if start == 0 || output_bytes[start - 1] != b'\n' {
violations += 1;
eprintln!(
"newline-before-endstream=y violation at offset {start}: \
preceding byte is 0x{:02x}",
output_bytes[start - 1]
);
}
}
assert_eq!(
violations, 0,
"newline-before-endstream=y: {violations} `endstream` keyword(s) not preceded by \\n"
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn newline_before_endstream_n_omits_extra_newline_for_eol_terminated_payload() {
let tmp = tempdir().unwrap();
let input = fixture_path("one-page.pdf");
let output = tmp.path().join("newline-n.pdf");
run_rewrite(
&input,
&output,
&[
"--full-rewrite",
"--newline-before-endstream=n",
"--compress-streams=n",
],
);
let output_bytes = std::fs::read(&output).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(output_bytes.clone())).unwrap();
let endstream_offsets = real_endstream_offsets(&output_bytes, &mut out_pdf);
assert!(
!endstream_offsets.is_empty(),
"newline-before-endstream=n: no stream objects found in output"
);
let mut found_eol_terminated = false;
for &start in &endstream_offsets {
if start >= 2 && output_bytes[start - 1] == b'\n' {
assert_ne!(
output_bytes[start - 2],
b'\n',
"newline-before-endstream=n: double \\n before `endstream` at offset {start}; \
flag=n must not insert an extra newline when the payload already ends with \\n.\n\
bytes[-4..0]: {:?}",
&output_bytes[start.saturating_sub(4)..start]
);
found_eol_terminated = true;
}
}
assert!(
found_eol_terminated,
"newline-before-endstream=n: no `endstream` was preceded by '\\n' in the output; \
the fixture may no longer produce an EOL-terminated payload with --compress-streams=n"
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
#[test]
fn combination_normalize_coalesce_compress_succeeds() {
let tmp = tempdir().unwrap();
let input = fixture_path("multi-contents-one-page.pdf");
let output = tmp.path().join("combo.pdf");
run_rewrite(
&input,
&output,
&[
"--full-rewrite",
"--normalize-content=y",
"--coalesce-contents",
"--compress-streams=y",
],
);
let output_bytes = std::fs::read(&output).unwrap();
let mut out_pdf = Pdf::open(Cursor::new(output_bytes)).unwrap();
let pages = page_refs(&mut out_pdf).unwrap();
assert_eq!(pages.len(), 1, "combination: output must have 1 page");
let page_obj = out_pdf.resolve(pages[0]).unwrap();
let page_dict = match page_obj {
Object::Dictionary(d) => d,
other => panic!("page must be a Dictionary, got {other:?}"),
};
assert!(
matches!(page_dict.get("Contents"), Some(Object::Reference(_))),
"combination: /Contents must be a single reference after coalesce"
);
if !skip_if_qpdf_missing() {
assert_qpdf_check(&output);
}
}
fn real_endstream_offsets(
output_bytes: &[u8],
out_pdf: &mut flpdf::Pdf<std::io::Cursor<Vec<u8>>>,
) -> Vec<usize> {
let refs = out_pdf.live_object_refs();
let mut offsets = Vec::new();
for oref in refs {
let obj = out_pdf.resolve(oref).expect("resolve must succeed");
let stream = match obj {
Object::Stream(s) => s,
_ => continue,
};
let data = &stream.data;
let mut anchor_lf = b"stream\n".to_vec();
anchor_lf.extend_from_slice(data);
let mut anchor_crlf = b"stream\r\n".to_vec();
anchor_crlf.extend_from_slice(data);
let anchor = if find_all_occurrences(output_bytes, &anchor_lf).len() == 1 {
anchor_lf
} else if find_all_occurrences(output_bytes, &anchor_crlf).len() == 1 {
anchor_crlf
} else {
let prefix: &[u8] = &data[..data.len().min(32)];
let mut short_lf = b"stream\n".to_vec();
short_lf.extend_from_slice(prefix);
let short_hits = find_all_occurrences(output_bytes, &short_lf);
if short_hits.len() == 1 {
anchor_lf = short_lf;
anchor_lf
} else {
panic!(
"real_endstream_offsets: could not uniquely anchor stream payload for {:?} \
(data len={}, lf hits={}, crlf hits={}). \
Fixture may need updating.",
oref,
data.len(),
find_all_occurrences(output_bytes, &anchor_lf).len(),
find_all_occurrences(output_bytes, &anchor_crlf).len(),
)
}
};
let anchor_pos = find_all_occurrences(output_bytes, &anchor)[0];
let after_payload = anchor_pos + anchor.len();
let endstream_kw = b"endstream";
let endstream_off = (after_payload..after_payload + 4)
.find(|&pos| {
pos + endstream_kw.len() <= output_bytes.len()
&& &output_bytes[pos..pos + endstream_kw.len()] == endstream_kw
})
.unwrap_or_else(|| {
panic!(
"real_endstream_offsets: `endstream` not found within 4 bytes after payload \
for {:?} at offset {}. bytes: {:?}",
oref,
after_payload,
&output_bytes[after_payload..after_payload.min(output_bytes.len() - 1) + 16]
)
});
offsets.push(endstream_off);
}
offsets
}
fn find_all_occurrences(haystack: &[u8], needle: &[u8]) -> Vec<usize> {
let mut results = Vec::new();
if needle.is_empty() || haystack.len() < needle.len() {
return results;
}
let mut start = 0;
while start + needle.len() <= haystack.len() {
if &haystack[start..start + needle.len()] == needle {
results.push(start);
start += needle.len();
} else {
start += 1;
}
}
results
}