use assert_cmd::Command;
use std::fs;
use std::process::Command as ProcessCommand;
fn qpdf_available() -> bool {
ProcessCommand::new("qpdf")
.arg("--version")
.output()
.is_ok_and(|output| {
output.status.success()
&& String::from_utf8_lossy(&output.stdout)
.lines()
.next()
.is_some_and(|line| line.trim() == "qpdf version 11.9.0")
})
}
#[test]
fn repeated_replace_input_remains_a_qpdf_usage_error() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping repeated replace-input differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
let qpdf_input = directory.path().join("qpdf-input.pdf");
let flpdf_input = directory.path().join("flpdf-input.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
let original = fs::read(&fixture).expect("read original fixture");
let qpdf = ProcessCommand::new("qpdf")
.args(["--replace-input", "--replace-input"])
.arg(&qpdf_input)
.output()
.expect("run qpdf 11.9.0 duplicate selector oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.args(["--replace-input", "--replace-input"])
.arg(&flpdf_input)
.output()
.expect("run flpdf duplicate selector");
assert_eq!(qpdf.status.code(), Some(2));
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
assert_eq!(fs::read(&qpdf_input).unwrap(), original);
assert_eq!(fs::read(&flpdf_input).unwrap(), original);
}
#[test]
fn top_level_replace_input_rewrites_unicode_input() {
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let input = directory.path().join("auto-ü.pdf");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, &input).expect("copy replace-input fixture");
let original = fs::read(&input).expect("read original input");
Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args([
"--deterministic-id",
"--object-streams=generate",
"--replace-input",
"./auto-ü.pdf",
])
.assert()
.success()
.stdout("")
.stderr("");
let replaced = fs::read(&input).expect("read replaced input");
assert_ne!(
replaced, original,
"replace-input must write the transformed PDF"
);
assert!(input.is_file(), "replace-input must keep the input path");
assert!(!directory.path().join("auto-ü.pdf.~qpdf-orig").exists());
assert!(!directory.path().join("auto-ü.pdf.~qpdf-orig#").exists());
assert!(!directory.path().join("auto-ü.pdf.~qpdf-temp#").exists());
}
#[test]
fn top_level_pages_replace_input_matches_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping page replace-input differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_directory = directory.path().join("qpdf");
let flpdf_directory = directory.path().join("flpdf");
fs::create_dir(&qpdf_directory).expect("create qpdf directory");
fs::create_dir(&flpdf_directory).expect("create flpdf directory");
let manifest = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
let primary = manifest.join("../../tests/fixtures/compat/three-page.pdf");
let secondary = manifest.join("../../tests/fixtures/compat/two-page.pdf");
for target in [&qpdf_directory, &flpdf_directory] {
fs::copy(&primary, target.join("input.pdf")).expect("copy primary input");
fs::copy(&secondary, target.join("secondary.pdf")).expect("copy secondary input");
}
let args = [
"--static-id",
"--qdf",
"input.pdf",
"--pages",
".",
"1",
"secondary.pdf",
"1",
"--",
"--replace-input",
];
let qpdf = ProcessCommand::new("qpdf")
.current_dir(&qpdf_directory)
.args(args)
.output()
.expect("run qpdf page replace-input oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(&flpdf_directory)
.env("FLPDF_PROGNAME", "qpdf")
.args(args)
.output()
.expect("run flpdf page replace-input");
assert_eq!(qpdf.status.code(), Some(0));
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(flpdf.stderr, qpdf.stderr);
assert_eq!(
fs::read(qpdf_directory.join("input.pdf")).unwrap(),
fs::read(flpdf_directory.join("input.pdf")).unwrap(),
"page replace-input must replace the primary input with qpdf's result"
);
}
#[test]
fn top_level_same_input_output_reports_qpdf_replace_input_guidance() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping same-file diagnostic differential");
return;
}
let directory = tempfile::tempdir().expect("temporary same-file directory");
let qpdf_directory = directory.path().join("qpdf");
let flpdf_directory = directory.path().join("flpdf");
fs::create_dir(&qpdf_directory).expect("create qpdf directory");
fs::create_dir(&flpdf_directory).expect("create flpdf directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, qpdf_directory.join("input.pdf")).expect("copy qpdf input");
fs::copy(&fixture, flpdf_directory.join("input.pdf")).expect("copy flpdf input");
let args = ["--static-id", "input.pdf", "input.pdf"];
let qpdf = ProcessCommand::new("qpdf")
.current_dir(&qpdf_directory)
.args(args)
.output()
.expect("run qpdf same-file diagnostic oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(&flpdf_directory)
.env("FLPDF_PROGNAME", "qpdf")
.args(args)
.output()
.expect("run flpdf same-file diagnostic");
assert_eq!(qpdf.status.code(), Some(2));
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(flpdf.stderr, qpdf.stderr);
}
#[test]
fn empty_pages_replace_input_reports_the_empty_conflict_before_missing_output() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping empty-pages diagnostic differential");
return;
}
let directory = tempfile::tempdir().expect("temporary empty-pages directory");
let qpdf_directory = directory.path().join("qpdf");
let flpdf_directory = directory.path().join("flpdf");
fs::create_dir(&qpdf_directory).expect("create qpdf directory");
fs::create_dir(&flpdf_directory).expect("create flpdf directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, qpdf_directory.join("input.pdf")).expect("copy qpdf input");
fs::copy(&fixture, flpdf_directory.join("input.pdf")).expect("copy flpdf input");
let args = [
"--static-id",
"--empty",
"--pages",
"input.pdf",
"1",
"--",
"--replace-input",
];
let qpdf = ProcessCommand::new("qpdf")
.current_dir(&qpdf_directory)
.args(args)
.output()
.expect("run qpdf empty-pages diagnostic oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(&flpdf_directory)
.env("FLPDF_PROGNAME", "qpdf")
.args(args)
.output()
.expect("run flpdf empty-pages diagnostic");
assert_eq!(qpdf.status.code(), Some(2));
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(flpdf.stderr, qpdf.stderr);
}
#[test]
fn top_level_replace_input_removes_attachment_like_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input attachment differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_directory = directory.path().join("qpdf");
let flpdf_directory = directory.path().join("flpdf");
fs::create_dir(&qpdf_directory).expect("create qpdf directory");
fs::create_dir(&flpdf_directory).expect("create flpdf directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/attachment-two-page.pdf");
fs::copy(&fixture, qpdf_directory.join("input.pdf")).expect("copy qpdf input");
fs::copy(&fixture, flpdf_directory.join("input.pdf")).expect("copy flpdf input");
let args = [
"--deterministic-id",
"--replace-input",
"--remove-attachment=attachment.txt",
"input.pdf",
];
let qpdf = ProcessCommand::new("qpdf")
.current_dir(&qpdf_directory)
.args(args)
.output()
.expect("run qpdf replace-input attachment oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(&flpdf_directory)
.env("FLPDF_PROGNAME", "qpdf")
.args(args)
.output()
.expect("run flpdf replace-input attachment");
assert_eq!(qpdf.status.code(), Some(0));
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(flpdf.stderr, qpdf.stderr);
assert!(flpdf_directory.join("input.pdf").is_file());
}
#[test]
fn top_level_replace_input_rejects_json_output_like_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input JSON differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_input = directory.path().join("qpdf-input.pdf");
let flpdf_input = directory.path().join("flpdf-input.pdf");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args(["--replace-input", "--json=2", "qpdf-input.pdf"])
.output()
.expect("run qpdf replace-input JSON oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["--replace-input", "--json=2", "flpdf-input.pdf"])
.output()
.expect("run flpdf replace-input JSON");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
assert!(flpdf_input.is_file(), "a rejected job must keep its input");
}
#[cfg(feature = "qpdf-zlib-compat")]
#[test]
fn top_level_replace_input_matches_qpdf_bytes() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input byte differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_directory = directory.path().join("qpdf");
let flpdf_directory = directory.path().join("flpdf");
fs::create_dir(&qpdf_directory).expect("create qpdf directory");
fs::create_dir(&flpdf_directory).expect("create flpdf directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
let qpdf_input = qpdf_directory.join("auto-ü.pdf");
let flpdf_input = flpdf_directory.join("auto-ü.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(&qpdf_directory)
.args([
"--deterministic-id",
"--object-streams=generate",
"--replace-input",
"./auto-ü.pdf",
])
.output()
.expect("run qpdf replace-input oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(&flpdf_directory)
.args([
"--deterministic-id",
"--object-streams=generate",
"--replace-input",
"./auto-ü.pdf",
])
.output()
.expect("run flpdf replace-input");
assert_eq!(flpdf.status.code(), Some(0));
assert_eq!(qpdf.status.code(), Some(0));
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(flpdf.stderr, qpdf.stderr);
assert_eq!(
fs::read(&flpdf_input).unwrap(),
fs::read(&qpdf_input).unwrap()
);
}
#[test]
fn top_level_replace_input_rejects_split_pages_like_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input split differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_input = directory.path().join("qpdf-input.pdf");
let flpdf_input = directory.path().join("flpdf-input.pdf");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args(["--replace-input", "--split-pages=1", "qpdf-input.pdf"])
.output()
.expect("run qpdf replace-input split oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["--replace-input", "--split-pages=1", "flpdf-input.pdf"])
.output()
.expect("run flpdf replace-input split");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
assert!(flpdf_input.is_file(), "a rejected job must keep its input");
}
#[test]
fn top_level_replace_input_rejects_an_output_file_like_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input output differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_input = directory.path().join("qpdf-input.pdf");
let flpdf_input = directory.path().join("flpdf-input.pdf");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args(["qpdf-input.pdf", "output.pdf", "--replace-input"])
.output()
.expect("run qpdf replace-input output oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["flpdf-input.pdf", "output.pdf", "--replace-input"])
.output()
.expect("run flpdf replace-input output");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
assert!(flpdf_input.is_file(), "a rejected job must keep its input");
}
#[test]
fn top_level_replace_input_rejects_empty_input_like_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input empty differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args(["--empty", "--replace-input"])
.output()
.expect("run qpdf empty replace-input oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["--empty", "--replace-input"])
.output()
.expect("run flpdf empty replace-input");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
}
#[test]
fn top_level_replace_input_rejects_inspection_like_qpdf() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input inspection differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_input = directory.path().join("qpdf-input.pdf");
let flpdf_input = directory.path().join("flpdf-input.pdf");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args(["--replace-input", "--check", "qpdf-input.pdf"])
.output()
.expect("run qpdf replace-input inspection oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["--replace-input", "--check", "flpdf-input.pdf"])
.output()
.expect("run flpdf replace-input inspection");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
assert!(flpdf_input.is_file(), "a rejected job must keep its input");
}
#[test]
fn top_level_replace_input_is_applied_after_job_json_file() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input job-json differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf_input = directory.path().join("qpdf-input.pdf");
let flpdf_input = directory.path().join("flpdf-input.pdf");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
fs::copy(&fixture, &qpdf_input).expect("copy qpdf input");
fs::copy(&fixture, &flpdf_input).expect("copy flpdf input");
fs::write(
directory.path().join("job.json"),
br#"{"deterministicId":"","objectStreams":"generate"}"#,
)
.expect("write partial job JSON");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args([
"--job-json-file=job.json",
"--replace-input",
"qpdf-input.pdf",
])
.output()
.expect("run qpdf job-json replace-input oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args([
"--job-json-file=job.json",
"--replace-input",
"flpdf-input.pdf",
])
.output()
.expect("run flpdf job-json replace-input");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
assert!(
flpdf_input.is_file(),
"replace-input must keep the input path"
);
}
#[test]
fn top_level_replace_input_empty_output_conflict_matches_qpdf_order() {
if !qpdf_available() {
eprintln!("qpdf 11.9.0 is unavailable; skipping replace-input empty-output differential");
return;
}
let directory = tempfile::tempdir().expect("temporary replace-input directory");
let qpdf = ProcessCommand::new("qpdf")
.current_dir(directory.path())
.args(["--empty", "output.pdf", "--replace-input"])
.output()
.expect("run qpdf empty-output replace-input oracle");
let flpdf = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["--empty", "flpdf-output.pdf", "--replace-input"])
.output()
.expect("run flpdf empty-output replace-input");
assert_eq!(flpdf.status.code(), qpdf.status.code());
assert_eq!(flpdf.stdout, qpdf.stdout);
assert_eq!(
String::from_utf8_lossy(&flpdf.stderr),
String::from_utf8_lossy(&qpdf.stderr).replace("qpdf", "flpdf")
);
}
#[test]
fn attachment_replace_input_with_an_output_path_is_rejected() {
let directory = tempfile::tempdir().expect("temporary directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
let attachment = directory.path().join("attachment.txt");
fs::write(&attachment, b"payload\n").expect("write attachment");
let with_attachment = directory.path().join("base.pdf");
Command::cargo_bin("flpdf")
.expect("flpdf binary")
.args(["--static-id"])
.arg(&fixture)
.arg("--add-attachment")
.arg(&attachment)
.args(["--"])
.arg(&with_attachment)
.assert()
.success();
for operation in [
vec!["--remove-attachment=attachment.txt".to_string()],
vec![
"--add-attachment".to_string(),
attachment.to_str().unwrap().to_string(),
"--".to_string(),
],
] {
let input = directory.path().join("in.pdf");
let output = directory.path().join("out.pdf");
let _ = fs::remove_file(&output);
fs::copy(&with_attachment, &input).expect("copy input");
let before = fs::read(&input).expect("read input");
Command::cargo_bin("flpdf")
.expect("flpdf binary")
.arg("--replace-input")
.args(&operation)
.arg(&input)
.arg(&output)
.assert()
.failure()
.code(2);
assert_eq!(
fs::read(&input).expect("read input"),
before,
"a rejected command must leave the input untouched for {operation:?}"
);
assert!(
!output.exists(),
"a rejected command must not create the output for {operation:?}"
);
}
}
#[test]
#[cfg(unix)]
fn attachment_diagnostics_preserve_non_utf8_bytes() {
use std::os::unix::ffi::OsStringExt;
let directory = tempfile::tempdir().expect("temporary directory");
let fixture = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/one-page.pdf");
let missing =
std::path::PathBuf::from(std::ffi::OsString::from_vec(b"missing-\xff.pdf".to_vec()));
let output = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.env("FLPDF_PROGNAME", "qpdf")
.args(["--remove-attachment=whatever"])
.arg(&missing)
.arg(directory.path().join("unused.pdf"))
.output()
.expect("flpdf runs");
assert!(!output.status.success());
assert!(
output
.stderr
.windows(16)
.any(|window| window.starts_with(b"missing-\xff.pdf")),
"a failed open must report the raw path bytes, got {:?}",
String::from_utf8_lossy(&output.stderr)
);
let key = std::path::PathBuf::from(std::ffi::OsString::from_vec(b"key-\xff".to_vec()));
let key_path = directory.path().join(&key);
if fs::write(&key_path, b"payload\n").is_err() {
eprintln!("skipping the attachment-key half: this filesystem rejects non-UTF-8 names");
return;
}
let with_attachment = directory.path().join("base.pdf");
Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.args(["--static-id"])
.arg(&fixture)
.arg("--add-attachment")
.arg(&key)
.args(["--"])
.arg(&with_attachment)
.assert()
.success();
let mut remove_arg = std::ffi::OsString::from("--remove-attachment=");
remove_arg.push(std::ffi::OsString::from_vec(b"key-\xff".to_vec()));
let output = Command::cargo_bin("flpdf")
.expect("flpdf binary")
.current_dir(directory.path())
.env("FLPDF_PROGNAME", "qpdf")
.args(["--static-id", "--verbose"])
.arg(&remove_arg)
.arg(&with_attachment)
.arg(directory.path().join("removed.pdf"))
.output()
.expect("flpdf runs");
assert!(
output.status.success(),
"verbose removal should succeed: {:?}",
String::from_utf8_lossy(&output.stderr)
);
let combined = [output.stdout.as_slice(), output.stderr.as_slice()].concat();
assert!(
combined.windows(6).any(|window| window == b"key-\xff\n"),
"verbose removal must echo the raw key bytes, got {:?}",
String::from_utf8_lossy(&combined)
);
}