use assert_cmd::Command;
use predicates::prelude::*;
use std::io::Write as _;
fn minimal_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn write_temp(bytes: &[u8]) -> tempfile::NamedTempFile {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(bytes).unwrap();
f
}
#[test]
fn rewrite_linearize_then_check_passes() {
let input = write_temp(&minimal_pdf_bytes());
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("linearized.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
input.path().to_str().unwrap(),
output.to_str().unwrap(),
])
.assert()
.success();
assert!(output.exists(), "linearized output file must be created");
assert!(
std::fs::metadata(&output).unwrap().len() > 0,
"linearized output must not be empty"
);
Command::cargo_bin("flpdf")
.unwrap()
.args(["check-linearization", output.to_str().unwrap()])
.assert()
.success()
.stdout(predicate::str::contains("linearization OK"));
}
#[test]
fn check_linearization_tampered_l_exits_1() {
let input = write_temp(&minimal_pdf_bytes());
let outdir = tempfile::tempdir().unwrap();
let linearized_path = outdir.path().join("linearized.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
input.path().to_str().unwrap(),
linearized_path.to_str().unwrap(),
])
.assert()
.success();
let mut bytes = std::fs::read(&linearized_path).unwrap();
let needle = b"/L 0";
if let Some(pos) = bytes.windows(needle.len()).position(|w| w == needle) {
let val_start = pos + 3;
let val_end = val_start + 10;
bytes[val_end - 1] = if bytes[val_end - 1] == b'9' {
b'0'
} else {
bytes[val_end - 1] + 1
};
} else {
panic!("could not find '/L 0' in linearized output for tampering");
}
let tampered_path = outdir.path().join("tampered.pdf");
std::fs::write(&tampered_path, &bytes).unwrap();
Command::cargo_bin("flpdf")
.unwrap()
.args(["check-linearization", tampered_path.to_str().unwrap()])
.assert()
.failure()
.code(1)
.stderr(predicate::str::contains("linearization check failed"));
}
#[test]
fn check_linearization_non_linearized_exits_1() {
let input = write_temp(&minimal_pdf_bytes());
Command::cargo_bin("flpdf")
.unwrap()
.args(["check-linearization", input.path().to_str().unwrap()])
.assert()
.failure()
.code(1)
.stderr(predicate::str::contains("not a linearized PDF"));
}
#[test]
fn rewrite_without_linearize_flag_still_works() {
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("out.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"../../tests/fixtures/minimal.pdf",
output.to_str().unwrap(),
])
.assert()
.success();
assert!(output.exists());
assert!(std::fs::metadata(&output).unwrap().len() > 0);
}
#[test]
fn check_linearization_missing_file_exits_2() {
Command::cargo_bin("flpdf")
.unwrap()
.args([
"check-linearization",
"/tmp/this_file_does_not_exist_flpdf_test.pdf",
])
.assert()
.failure()
.code(2);
}
#[test]
fn linearize_inherits_source_version() {
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("lin.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
"../../tests/fixtures/compat/one-page.pdf",
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
assert!(
bytes.starts_with(b"%PDF-1.3\n"),
"linearized header must be %PDF-1.3 (inherited from source); got: {}",
String::from_utf8_lossy(&bytes[..bytes.len().min(20)])
);
}
#[test]
fn linearize_min_version_raises_header() {
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("lin-min17.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
"--min-version=1.7",
"../../tests/fixtures/compat/one-page.pdf",
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
assert!(
bytes.starts_with(b"%PDF-1.7\n"),
"with --min-version=1.7 the header must be %PDF-1.7; got: {}",
String::from_utf8_lossy(&bytes[..bytes.len().min(20)])
);
}
#[test]
fn linearize_force_version_overrides() {
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("lin-force14.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
"--force-version=1.4",
"../../tests/fixtures/compat/one-page.pdf",
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
assert!(
bytes.starts_with(b"%PDF-1.4\n"),
"with --force-version=1.4 the header must be %PDF-1.4; got: {}",
String::from_utf8_lossy(&bytes[..bytes.len().min(20)])
);
}
#[test]
fn linearize_force_version_overrides_linearize_floor() {
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("lin-force10.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
"--force-version=1.0",
"../../tests/fixtures/compat/one-page.pdf",
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
assert!(
bytes.starts_with(b"%PDF-1.0\n"),
"with --force-version=1.0 the header must be %PDF-1.0; got: {}",
String::from_utf8_lossy(&bytes[..bytes.len().min(20)])
);
}
#[test]
fn linearize_no_source_id_omits_id_key() {
let input = write_temp(&minimal_pdf_bytes());
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("linearized.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
input.path().to_str().unwrap(),
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
let id_needle = b"/ID";
assert!(
!bytes.windows(id_needle.len()).any(|w| w == id_needle),
"linearized output must not contain /ID when source has none and --static-id is off"
);
}
#[test]
fn linearize_static_id_emits_id_key() {
let input = write_temp(&minimal_pdf_bytes());
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("linearized-static.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
"--static-id",
input.path().to_str().unwrap(),
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
let id_needle = b"/ID";
assert!(
bytes.windows(id_needle.len()).any(|w| w == id_needle),
"linearized output with --static-id must contain /ID"
);
}
#[test]
fn parse_pdf_version_valid() {
use flpdf::parse_pdf_version;
assert_eq!(parse_pdf_version("1.3"), Some((1, 3)));
assert_eq!(parse_pdf_version("1.7"), Some((1, 7)));
assert_eq!(parse_pdf_version("2.0"), Some((2, 0)));
assert_eq!(parse_pdf_version("1.10"), Some((1, 10)));
assert_eq!(parse_pdf_version("invalid"), None);
assert_eq!(parse_pdf_version(""), None);
}
#[test]
fn effective_version_source_inherit() {
use flpdf::{effective_pdf_version, WriteOptions};
let opts = WriteOptions::default();
assert_eq!(effective_pdf_version("1.3", &opts, false), "1.3");
assert_eq!(effective_pdf_version("1.7", &opts, false), "1.7");
}
#[test]
fn effective_version_linearize_floor() {
use flpdf::{effective_pdf_version, WriteOptions};
let opts = WriteOptions::default();
assert_eq!(effective_pdf_version("1.0", &opts, true), "1.2");
assert_eq!(effective_pdf_version("1.3", &opts, true), "1.3");
}
#[test]
fn effective_version_min_version() {
use flpdf::{effective_pdf_version, WriteOptions};
let mut opts = WriteOptions::default();
opts.min_version = Some("1.7".to_string());
assert_eq!(effective_pdf_version("1.3", &opts, false), "1.7");
opts.min_version = Some("1.3".to_string());
assert_eq!(effective_pdf_version("1.7", &opts, false), "1.7");
}
#[test]
fn effective_version_force_version() {
use flpdf::{effective_pdf_version, WriteOptions};
let mut opts = WriteOptions::default();
opts.force_version = Some("1.4".to_string());
assert_eq!(effective_pdf_version("1.7", &opts, false), "1.4");
opts.force_version = Some("1.0".to_string());
assert_eq!(effective_pdf_version("1.3", &opts, true), "1.0");
}
#[test]
fn linearize_part1_startxref_is_zero_main_startxref_is_real() {
let input = write_temp(&minimal_pdf_bytes());
let outdir = tempfile::tempdir().unwrap();
let output = outdir.path().join("linearized.pdf");
Command::cargo_bin("flpdf")
.unwrap()
.args([
"rewrite",
"--linearize",
"--static-id",
input.path().to_str().unwrap(),
output.to_str().unwrap(),
])
.assert()
.success();
let bytes = std::fs::read(&output).unwrap();
let needle = b"startxref\n";
let parse_val = |pos: usize| -> usize {
let val_start = pos + needle.len();
let val_end = bytes[val_start..]
.iter()
.position(|&b| b == b'\n')
.map(|p| val_start + p)
.expect("startxref value must be newline-terminated");
std::str::from_utf8(&bytes[val_start..val_end])
.expect("UTF-8")
.trim()
.parse()
.expect("decimal")
};
let first_pos = bytes
.windows(needle.len())
.position(|w| w == needle)
.expect("must have at least one startxref");
let part1_val: usize = parse_val(first_pos);
assert_eq!(
part1_val, 0,
"Part 1 first trailer startxref must be 0 (qpdf linearized convention)"
);
let last_pos = bytes
.windows(needle.len())
.rposition(|w| w == needle)
.expect("must have at least two startxref");
let main_val: usize = parse_val(last_pos);
let last_xref_pos = (0..bytes.len().saturating_sub(3))
.rev()
.find(|&i| {
&bytes[i..i + 4] == b"xref"
&& (i == 0 || bytes[i - 1].is_ascii_whitespace())
&& (i + 4 >= bytes.len() || bytes[i + 4].is_ascii_whitespace())
})
.expect("must have at least one standalone xref keyword");
assert_eq!(
main_val, last_xref_pos,
"Part 6 main startxref ({main_val}) must equal last xref keyword offset ({last_xref_pos})"
);
}