use std::cell::RefCell;
use std::io::{Read, Seek};
use std::rc::Rc;
use crate::acroform_document_helper::DrMap;
use crate::object_handle::{ObjectHandle, ResourceConflicts};
use crate::resource_finder::ResourceFinder;
use crate::resource_replacer::ResourceReplacer;
#[cfg(test)]
use crate::resource_replacer::{filter_resource_names, replace_resource_names_with_context};
#[cfg(test)]
use crate::writer::DecodeLevel;
use crate::{Pdf, Result};
#[cfg(test)]
fn rewrite_appearance_content(decoded: &[u8], dr_map: &DrMap) -> Vec<u8> {
match replace_resource_names_with_context(decoded, dr_map.renames(), None) {
Ok(Some(bytes)) => bytes,
Ok(None) | Err(_) => decoded.to_vec(),
}
}
#[cfg(test)]
fn rewrite_appearance_content_with_context(
decoded: &[u8],
dr_map: &DrMap,
stream: &ObjectHandle,
) -> Result<Vec<u8>> {
let mut finder = ResourceFinder::default();
if let Err(error) = stream.parse_as_contents(&mut finder) {
stream.warn_if_possible(&format!("Unable to parse appearance stream: {error}"))?;
return Ok(decoded.to_vec());
}
match filter_resource_names(decoded, dr_map.renames(), finder.names_by_resource_type()) {
Ok(bytes) => Ok(bytes),
Err(error) => {
stream.warn_if_possible(&format!("Unable to parse appearance stream: {error}"))?;
Ok(decoded.to_vec())
}
}
}
pub(crate) fn adjust_appearance_stream_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
stream: &ObjectHandle,
dr_map: &DrMap,
) -> Result<()> {
if dr_map.is_empty() {
return Ok(());
}
stream.try_dereference()?;
let Some(stream_dict) = stream.as_stream_dict() else {
return Ok(()); };
let resources_value = stream_dict.try_get_key(b"/Resources")?;
if resources_value.try_is_null()? {
return Ok(());
}
let resources_terminal = resources_value.clone();
resources_terminal.try_dereference()?;
if !resources_terminal.try_is_dictionary()? {
return Ok(());
}
let was_indirect = resources_value.is_indirect()
|| resources_value.object_ref().is_some()
|| resources_terminal.object_ref().is_some();
let private_resources = resources_terminal.shallow_copy()?;
let private_resources = if was_indirect {
pdf.make_indirect_from_object_handle(private_resources)?
} else {
private_resources
};
stream_dict.replace_key(b"/Resources", private_resources.clone())?;
let merge_with = ObjectHandle::dictionary(
dr_map
.categories()
.map(|category| {
(
canonical_resource_name(category),
ObjectHandle::dictionary(Vec::new()),
)
})
.collect(),
);
private_resources.merge_resources(&merge_with, None)?;
for category in dr_map.categories() {
let category_key = canonical_resource_name(category);
let subdict = private_resources.try_get_key(&category_key)?;
subdict.try_dereference()?;
let Some(renames) = dr_map.category(category) else {
continue; };
if !subdict.try_is_dictionary()? {
continue;
}
let staged = merge_with.try_get_key(&category_key)?;
for (old_name, new_name) in renames {
let old_key = canonical_resource_name(old_name);
let new_key = canonical_resource_name(new_name);
let existing_new = subdict.try_get_key(&new_key)?;
if !existing_new.try_is_null()? {
staged.replace_key(&new_key, existing_new)?;
}
let existing_old = subdict.try_get_key(&old_key)?;
if !existing_old.try_is_null()? {
subdict.replace_key(&new_key, existing_old)?;
subdict.remove_key(&old_key);
}
}
}
let mut conflicts = ResourceConflicts::new();
private_resources.merge_resources(&merge_with, Some(&mut conflicts))?;
let mut local_dr_map = dr_map.clone();
extend_dr_map_from_conflicts(&mut local_dr_map, &conflicts);
for category_key in private_resources.try_get_keys()? {
let category = private_resources.try_get_key(&category_key)?;
category.try_dereference()?;
if category.try_is_dictionary()? && category.try_get_keys()?.is_empty() {
private_resources.remove_key(&category_key);
}
}
let mut finder = ResourceFinder::default();
if let Err(error) = stream.parse_as_contents(&mut finder) {
stream.warn_if_possible(&format!("Unable to parse appearance stream: {error}"))?;
return Ok(());
}
let replacer = ResourceReplacer::new(local_dr_map.renames(), finder.names_by_resource_type());
if let Err(error) = stream.add_token_filter(Rc::new(RefCell::new(replacer))) {
stream.warn_if_possible(&format!("Unable to parse appearance stream: {error}"))?;
}
Ok(())
}
fn canonical_resource_name(name: &[u8]) -> Vec<u8> {
let name = name.strip_prefix(b"/").unwrap_or(name);
let mut result = Vec::with_capacity(name.len() + 1);
result.push(b'/');
result.extend_from_slice(name);
result
}
fn extend_dr_map_from_conflicts(dr_map: &mut DrMap, conflicts: &ResourceConflicts) {
for (category, category_conflicts) in conflicts {
let category = category.strip_prefix(b"/").unwrap_or(category);
for (old_name, new_name) in category_conflicts {
dr_map.insert_rename(
category,
old_name.strip_prefix(b"/").unwrap_or(old_name).to_vec(),
new_name.strip_prefix(b"/").unwrap_or(new_name).to_vec(),
);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::pipeline::{Pipeline, PipelineError, PipelineResult};
use crate::PdfOpenOptions;
use crate::{ObjectHandle, ObjectRef, QPDFLogger};
use crate::{PageDocumentHelper, PageInput, PdfWriter};
use std::io::Cursor;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
fn dr_map_with(category: &[u8], old: &[u8], new: &[u8]) -> DrMap {
DrMap::for_test(category, old, new)
}
#[derive(Default)]
struct HandleDictionary {
entries: Vec<(String, ObjectHandle)>,
}
impl HandleDictionary {
fn new() -> Self {
Self::default()
}
fn insert(&mut self, key: &str, value: ObjectHandle) {
self.entries.retain(|(existing, _)| existing != key);
self.entries.push((key.to_owned(), value));
}
fn into_handle(self) -> ObjectHandle {
ObjectHandle::dictionary(
self.entries
.into_iter()
.map(|(key, value)| {
let key = key.strip_prefix('/').unwrap_or(&key);
(format!("/{key}").into_bytes(), value)
})
.collect(),
)
}
}
struct HandleFixture;
impl HandleFixture {
fn dictionary(value: HandleDictionary) -> ObjectHandle {
value.into_handle()
}
fn integer(value: i64) -> ObjectHandle {
ObjectHandle::integer(value)
}
fn name(value: Vec<u8>) -> ObjectHandle {
ObjectHandle::name(value)
}
}
struct HandleDict(std::collections::BTreeMap<Vec<u8>, ObjectHandle>);
impl HandleDict {
fn get(&self, key: &str) -> Option<ObjectHandle> {
let key = format!("/{}", key.strip_prefix('/').unwrap_or(key)).into_bytes();
self.0.get(&key).cloned()
}
fn get_ref(&self, key: &str) -> Option<ObjectRef> {
self.get(key).and_then(|value| value.object_ref())
}
}
fn handle_dictionary(handle: ObjectHandle) -> Option<HandleDict> {
handle.as_dictionary().map(HandleDict)
}
trait HandleObjectAccess {
fn get(&self, key: &str) -> Option<ObjectHandle>;
fn get_ref(&self, key: &str) -> Option<ObjectRef>;
}
impl HandleObjectAccess for ObjectHandle {
fn get(&self, key: &str) -> Option<ObjectHandle> {
let key = format!("/{}", key.strip_prefix('/').unwrap_or(key)).into_bytes();
self.try_get_key(&key).ok().filter(|value| !value.is_null())
}
fn get_ref(&self, key: &str) -> Option<ObjectRef> {
self.get(key).and_then(|value| value.object_ref())
}
}
#[test]
fn resource_replacement_preserves_diagnostic_bytes_and_rewrites_later_name() {
let dr_map = DrMap::for_test(b"Font", b"F1", b"F1_1");
let content = b"<0g> /F1 12 Tf";
assert_eq!(
rewrite_appearance_content(content, &dr_map),
b"<0g> /F1_1 12 Tf"
);
}
#[test]
fn incomplete_inline_image_appearance_keeps_prefix_replacement_and_qpdf_separator() {
let dr_map = DrMap::for_test(b"Font", b"F1", b"F1_1");
let content = b"/F1 12 Tf BI ID";
assert_eq!(
rewrite_appearance_content(content, &dr_map),
b"/F1_1 12 Tf BI ID "
);
}
#[test]
fn fatal_structure_error_keeps_appearance_content_byte_identical() {
let dr_map = DrMap::for_test(b"Font", b"F1", b"F1_1");
let content = b"/F1 12 Tf [";
assert_eq!(rewrite_appearance_content(content, &dr_map), content);
}
fn minimal_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(
format!("xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \n").as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn open_minimal() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(minimal_pdf_bytes())).expect("minimal pdf should parse")
}
fn dictionary(entries: &[(&str, ObjectHandle)]) -> ObjectHandle {
let mut result = HandleDictionary::new();
for (key, value) in entries {
result.insert(key, value.clone());
}
result.into_handle()
}
fn indirect<R: Read + Seek>(pdf: &mut Pdf<R>, object_ref: ObjectRef) -> ObjectHandle {
pdf.get_object_handle(object_ref)
}
fn set_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
n: u32,
entries: &[(&str, ObjectHandle)],
) -> ObjectRef {
let r = ObjectRef::new(n, 0);
pdf.replace_object(r, dictionary(entries))
.expect("set canonical dictionary fixture");
r
}
fn set_stream<R: Read + Seek>(
pdf: &mut Pdf<R>,
n: u32,
entries: &[(&str, ObjectHandle)],
data: &[u8],
) -> ObjectRef {
let r = ObjectRef::new(n, 0);
pdf.replace_object(
r,
ObjectHandle::stream(dictionary(entries), Rc::new(data.to_vec())),
)
.expect("set canonical stream fixture");
r
}
fn stream_handle<R: Read + Seek>(pdf: &mut Pdf<R>, stream_ref: ObjectRef) -> ObjectHandle {
let stream = pdf.get_object_handle(stream_ref);
stream.try_is_scalar().expect("resolve stream fixture");
stream
}
fn stream_dict(stream: &ObjectHandle) -> ObjectHandle {
stream
.as_stream_dict()
.expect("appearance fixture must be a stream")
}
fn stream_bytes(stream: &ObjectHandle) -> Vec<u8> {
stream
.as_stream_data()
.expect("appearance fixture must have stream data")
.as_ref()
.clone()
}
fn filtered_stream_bytes(stream: &ObjectHandle) -> Vec<u8> {
stream
.get_stream_data(crate::writer::DecodeLevel::All)
.expect("appearance token filter must produce stream data")
.as_ref()
.clone()
}
struct FailingWarningSink;
impl Pipeline for FailingWarningSink {
fn identifier(&self) -> &str {
"appearance test warning sink"
}
fn write(&mut self, _data: &[u8]) -> PipelineResult<()> {
Err(PipelineError::runtime("appearance warning sink failed"))
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
struct RecordingWarningSink(Arc<Mutex<Vec<u8>>>);
impl Pipeline for RecordingWarningSink {
fn identifier(&self) -> &str {
"appearance recording warning sink"
}
fn write(&mut self, data: &[u8]) -> PipelineResult<()> {
self.0
.lock()
.expect("appearance warning trace lock")
.extend_from_slice(data);
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
fn key(handle: &ObjectHandle, name: &[u8]) -> ObjectHandle {
handle
.try_get_key(name)
.expect("read canonical fixture key")
}
fn adjust_appearance_stream_via_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
ap_stream_ref: ObjectRef,
dr_map: &DrMap,
) -> Result<()> {
let stream = pdf.get_object_handle(ap_stream_ref);
super::adjust_appearance_stream_handle(pdf, &stream, dr_map)
}
#[test]
fn adjust_appearance_stream_empty_dr_map_is_noop() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let font_handle = indirect(&mut pdf, font_ref);
let font_dict = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert("F1", font_handle);
d
});
let resources_ref = set_dict(&mut pdf, 3, &[("Font", font_dict)]);
let resources_handle = indirect(&mut pdf, resources_ref);
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", resources_handle)],
b"/F1 18 Tf",
);
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &DrMap::new()).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(stream_bytes(&stream), b"/F1 18 Tf");
assert_eq!(
stream_dict(&stream).get_ref("Resources"),
Some(resources_ref)
);
}
#[test]
fn adjust_appearance_stream_no_resources_is_noop() {
let mut pdf = open_minimal();
let ap_ref = set_stream(&mut pdf, 4, &[], b"/F1 18 Tf");
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(stream_bytes(&stream), b"/F1 18 Tf");
assert!(stream_dict(&stream).get("Resources").is_none());
}
#[test]
fn adjust_appearance_stream_rewrites_content_and_privatizes_indirect_resources() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let font_handle = indirect(&mut pdf, font_ref);
let font_dict = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert("F1", font_handle);
d
});
let resources_ref = set_dict(&mut pdf, 3, &[("Font", font_dict)]);
let resources_handle = indirect(&mut pdf, resources_ref);
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", resources_handle)],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf");
let new_resources_ref = stream_dict(&stream)
.get_ref("Resources")
.expect("Resources should stay an indirect reference");
assert_ne!(
new_resources_ref, resources_ref,
"must be a FRESH private object, not the original shared one"
);
let new_resources = stream_handle(&mut pdf, new_resources_ref);
let new_font = handle_dictionary(key(&new_resources, b"/Font"))
.expect("new resources must contain a Font dictionary");
assert_eq!(new_font.get_ref("F1_1"), Some(font_ref));
assert!(new_font.get("F1").is_none());
let original_resources = stream_handle(&mut pdf, resources_ref);
let orig_font = handle_dictionary(key(&original_resources, b"/Font"))
.expect("original resources must contain a Font dictionary");
assert_eq!(orig_font.get_ref("F1"), Some(font_ref));
}
#[test]
fn canonical_adjust_appearance_stream_rewrites_a_live_handle_without_materializing_it() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let font_handle = indirect(&mut pdf, font_ref);
let font_dict = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert("F1", font_handle);
d
});
let resources_ref = set_dict(&mut pdf, 3, &[("Font", font_dict)]);
let resources_handle = indirect(&mut pdf, resources_ref);
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", resources_handle)],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &dr_map).unwrap();
let stream_dict = ap
.as_stream_dict()
.expect("expected live stream dictionary");
let resources = stream_dict.try_get_key(b"/Resources").unwrap();
resources.try_is_scalar().unwrap();
let font = resources
.try_get_key(b"/Font")
.unwrap()
.try_get_key(b"/F1_1")
.unwrap();
assert_eq!(font.object_ref(), Some(font_ref));
assert!(resources.try_get_key(b"/F1").unwrap().is_null());
let decoded = ap
.get_stream_data(crate::writer::DecodeLevel::Generalized)
.unwrap();
assert_eq!(decoded.as_slice(), b"/F1_1 18 Tf");
assert_ne!(resources.object_ref(), Some(resources_ref));
let original = pdf.get_object_handle(resources_ref);
original.try_is_scalar().unwrap();
let original_font = original
.try_get_key(b"/Font")
.unwrap()
.try_get_key(b"/F1")
.unwrap();
assert_eq!(original_font.object_ref(), Some(font_ref));
}
#[test]
fn canonical_adjust_appearance_stream_reaches_the_linearized_writer_filter_route() {
let mut pdf = Pdf::empty().expect("empty PDF should parse");
let stream = pdf
.new_stream_with_data(Rc::new(b"/F1 18 Tf".to_vec()))
.expect("create appearance stream");
stream
.as_stream_dict()
.expect("stream dictionary")
.replace_key(
b"/Resources",
HandleFixture::dictionary({
let mut resources = HandleDictionary::new();
resources.insert(
"Font",
HandleFixture::dictionary({
let mut fonts = HandleDictionary::new();
fonts.insert("F1", HandleFixture::integer(1));
fonts
}),
);
resources
}),
)
.expect("install appearance resources");
let page = HandleFixture::dictionary({
let mut page = HandleDictionary::new();
page.insert("Type", HandleFixture::name(b"Page".to_vec()));
page.insert(
"MediaBox",
ObjectHandle::array(vec![
HandleFixture::integer(0),
HandleFixture::integer(0),
HandleFixture::integer(10),
HandleFixture::integer(10),
]),
);
page.insert("Contents", stream.clone());
page
});
PageDocumentHelper::new(&mut pdf)
.add_page(PageInput::direct(page), false)
.expect("add a page for linearization");
super::adjust_appearance_stream_handle(
&mut pdf,
&stream,
&dr_map_with(b"Font", b"F1", b"F1_1"),
)
.expect("attach the live ResourceReplacer");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_linearization(true);
writer.set_compress_streams(false);
writer.set_decode_level(crate::writer::DecodeLevel::Generalized);
writer.set_static_id(true);
writer.set_output_memory().expect("configure memory output");
writer.write().expect("linearized writer should succeed");
let output = writer.get_buffer().expect("take linearized output");
assert!(
output
.windows(b"/F1 18 Tfendstream".len())
.any(|window| window == b"/F1 18 Tfendstream"),
"linearized output must preserve qpdf's stateful-filter result"
);
}
#[test]
fn canonical_adjust_appearance_stream_empty_dr_map_is_a_noop() {
let mut pdf = open_minimal();
let ap_ref = set_stream(&mut pdf, 4, &[], b"/F1 18 Tf");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &DrMap::new()).unwrap();
assert_eq!(ap.as_stream_data().unwrap().as_slice(), b"/F1 18 Tf");
assert!(ap
.as_stream_dict()
.unwrap()
.try_get_key(b"/Resources")
.unwrap()
.is_null());
}
#[test]
fn canonical_adjust_appearance_stream_keeps_direct_resources_direct() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let resources = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
let mut fonts = HandleDictionary::new();
fonts.insert("F1", indirect(&mut pdf, font_ref));
d.insert("Font", HandleFixture::dictionary(fonts));
d
});
let ap_ref = set_stream(&mut pdf, 4, &[("Resources", resources)], b"/F1 18 Tf");
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &dr_map).unwrap();
let stream_dict = ap
.as_stream_dict()
.expect("expected live stream dictionary");
let resources = stream_dict.try_get_key(b"/Resources").unwrap();
assert!(resources.as_dictionary().is_some());
assert!(resources.object_ref().is_none());
let fonts = resources.try_get_key(b"/Font").unwrap();
assert!(!fonts.try_get_key(b"/F1_1").unwrap().is_null());
assert!(fonts.try_get_key(b"/F1").unwrap().is_null());
}
#[test]
fn canonical_adjust_appearance_stream_keeps_non_dictionary_resource_category() {
let mut pdf = open_minimal();
let resources = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert("Font", HandleFixture::integer(7));
d
});
let ap_ref = set_stream(&mut pdf, 4, &[("Resources", resources)], b"/F1 18 Tf");
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &dr_map).unwrap();
let resources = ap
.as_stream_dict()
.unwrap()
.try_get_key(b"/Resources")
.unwrap();
assert_eq!(
resources.try_get_key(b"/Font").unwrap().as_integer(),
Some(7)
);
}
#[test]
fn canonical_adjust_appearance_stream_keeps_non_dictionary_resources_untouched() {
let mut pdf = open_minimal();
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::integer(7))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &dr_map).unwrap();
assert_eq!(ap.as_stream_data().unwrap().as_slice(), b"/F1 18 Tf");
let resources = ap
.as_stream_dict()
.unwrap()
.try_get_key(b"/Resources")
.unwrap();
assert_eq!(resources.as_integer(), Some(7));
}
#[test]
fn canonical_adjust_appearance_stream_keeps_resources_when_content_cannot_decode() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let font_handle = indirect(&mut pdf, font_ref);
let font_dict = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert("F1", font_handle);
d
});
let resources_ref = set_dict(&mut pdf, 3, &[("Font", font_dict)]);
let resources_handle = indirect(&mut pdf, resources_ref);
let raw = b"not a supported filter payload";
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", resources_handle),
("Filter", HandleFixture::name(b"FlateDecode".to_vec())),
],
raw,
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &dr_map).unwrap();
assert_eq!(ap.as_stream_data().unwrap().as_slice(), raw);
let stream_dict = ap.as_stream_dict().unwrap();
let resources = stream_dict.try_get_key(b"/Resources").unwrap();
resources.try_is_scalar().unwrap();
assert!(!resources
.try_get_key(b"/Font")
.unwrap()
.try_get_key(b"/F1_1")
.unwrap()
.is_null());
assert!(resources
.try_get_key(b"/Font")
.unwrap()
.try_get_key(b"/F1")
.unwrap()
.is_null());
}
#[test]
fn canonical_adjust_appearance_stream_propagates_warning_sink_failure() {
let mut pdf = open_minimal();
let resources = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert(
"Font",
HandleFixture::dictionary({
let mut fonts = HandleDictionary::new();
fonts.insert("F1", HandleFixture::integer(1));
fonts
}),
);
d
});
let ap_ref = set_stream(&mut pdf, 4, &[("Resources", resources)], b"/F1 18 Tf [");
let logger = QPDFLogger::create();
logger.set_warn(Some(crate::PipelineHandle::new(FailingWarningSink)));
pdf.set_logger(logger);
let error = adjust_appearance_stream_via_handle(
&mut pdf,
ap_ref,
&dr_map_with(b"Font", b"F1", b"F1_1"),
)
.expect_err("appearance warning sink failure must propagate");
assert!(matches!(
error,
crate::Error::System(message) if message == "appearance warning sink failed"
));
}
#[test]
fn canonical_adjust_appearance_stream_warns_and_rewrites_the_prefix() {
let mut pdf = open_minimal();
let resources = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert(
"Font",
HandleFixture::dictionary({
let mut fonts = HandleDictionary::new();
fonts.insert("F1", HandleFixture::integer(1));
fonts
}),
);
d
});
let ap_ref = set_stream(&mut pdf, 4, &[("Resources", resources)], b"/F1 18 Tf [");
let warnings = Arc::new(Mutex::new(Vec::new()));
let logger = QPDFLogger::create();
logger.set_warn(Some(crate::PipelineHandle::new(RecordingWarningSink(
Arc::clone(&warnings),
))));
pdf.set_logger(logger);
adjust_appearance_stream_via_handle(
&mut pdf,
ap_ref,
&dr_map_with(b"Font", b"F1", b"F1_1"),
)
.expect("a successful re-warning keeps the appearance adjustment non-fatal");
assert_eq!(
filtered_stream_bytes(&stream_handle(&mut pdf, ap_ref)),
b"/F1_1 18 Tf ["
);
let warning_bytes = warnings.lock().expect("appearance warning trace lock");
let warnings = String::from_utf8_lossy(&warning_bytes);
assert!(
warnings.contains(
"object 4 0 stream 4 0 (content, offset 11): parse error while reading object"
),
"qpdf's appearance parser warning must be delivered: {warnings}"
);
}
#[test]
fn detached_appearance_rewrite_keeps_structural_failure_fallback() {
let stream =
ObjectHandle::stream(ObjectHandle::dictionary(Vec::new()), Rc::new(Vec::new()));
let rewritten = rewrite_appearance_content_with_context(
b"/F1 18 Tf [",
&dr_map_with(b"Font", b"F1", b"F1_1"),
&stream,
)
.expect("detached structural failure keeps the original bytes");
assert_eq!(rewritten, b"/F1 18 Tf [");
}
#[test]
fn appearance_hard_parse_failure_rewarns_and_preserves_content() {
let mut pdf = open_minimal();
let ap_ref = set_stream(
&mut pdf,
4,
&[(
"Resources",
HandleFixture::dictionary(HandleDictionary::new()),
)],
b"/F1 18 Tf 999999999999999999999999",
);
let stream = stream_handle(&mut pdf, ap_ref);
let decoded = stream
.get_stream_data(DecodeLevel::Generalized)
.expect("appearance stream data");
let rewritten = rewrite_appearance_content_with_context(
&decoded,
&dr_map_with(b"Font", b"F1", b"F1_1"),
&stream,
)
.expect("appearance parse failure is caught and re-warned");
assert_eq!(rewritten.as_slice(), decoded.as_slice());
}
#[test]
fn canonical_adjust_appearance_stream_rewrites_second_order_resource_conflicts() {
let mut pdf = open_minimal();
let first_font_ref = ObjectRef::new(5, 0);
let second_font_ref = ObjectRef::new(6, 0);
pdf.replace_object(
first_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
pdf.replace_object(
second_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let first_font = indirect(&mut pdf, first_font_ref);
let second_font = indirect(&mut pdf, second_font_ref);
let font_dict = HandleFixture::dictionary({
let mut d = HandleDictionary::new();
d.insert("F1", first_font);
d.insert("F1_1", second_font);
d
});
let resources_ref = set_dict(&mut pdf, 3, &[("Font", font_dict)]);
let resources_handle = indirect(&mut pdf, resources_ref);
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", resources_handle)],
b"/F1 18 Tf /F1_1 12 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let ap = pdf.get_object_handle(ap_ref);
ap.try_is_scalar().unwrap();
super::adjust_appearance_stream_handle(&mut pdf, &ap, &dr_map).unwrap();
let stream_dict = ap.as_stream_dict().unwrap();
let resources = stream_dict.try_get_key(b"/Resources").unwrap();
resources.try_is_scalar().unwrap();
let fonts = resources.try_get_key(b"/Font").unwrap();
assert_eq!(
fonts.try_get_key(b"/F1_1").unwrap().object_ref(),
Some(first_font_ref)
);
assert_eq!(
fonts.try_get_key(b"/F1_1_1").unwrap().object_ref(),
Some(second_font_ref)
);
let decoded = ap
.get_stream_data(crate::writer::DecodeLevel::Generalized)
.unwrap();
assert_eq!(decoded.as_slice(), b"/F1_1 18 Tf /F1_1_1 12 Tf");
}
#[test]
fn adjust_appearance_stream_incomplete_inline_image_keeps_resources_and_prefix_consistent() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, font_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 12 Tf BI ID",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 12 Tf BI ID ");
let font = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.and_then(|resources| resources.get("Font"))
.and_then(handle_dictionary)
.expect("appearance stream should retain a Font resource dictionary");
assert_eq!(font.get_ref("F1_1"), Some(font_ref));
assert!(font.get("F1").is_none());
}
#[test]
fn adjust_appearance_stream_direct_resources_stays_direct() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, font_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf");
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(font.get_ref("F1_1"), Some(font_ref));
}
#[test]
fn adjust_appearance_stream_ensures_and_drops_empty_category() {
let mut pdf = open_minimal();
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(HandleDictionary::new()));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"q Q",
);
let dr_map = dr_map_with(b"ExtGState", b"GS1", b"GS1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("expected direct Resources dict");
assert!(
resources.get("ExtGState").is_none(),
"empty /ExtGState sub-dict must be dropped, not left behind"
);
assert!(resources.get("Font").is_none());
}
#[test]
fn adjust_appearance_stream_rewrites_content_when_category_subdict_is_indirect() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.replace_object(font_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let font_dict_ref = ObjectRef::new(6, 0);
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, font_ref));
pdf.replace_object(font_dict_ref, HandleFixture::dictionary(font_dict))
.unwrap();
let mut resources = HandleDictionary::new();
resources.insert("Font", indirect(&mut pdf, font_dict_ref));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf");
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(font.get_ref("F1_1"), Some(font_ref));
assert!(font.get("F1").is_none());
}
#[test]
fn adjust_appearance_stream_double_conflict_mints_fresh_local_name() {
let mut pdf = open_minimal();
let f1_font_ref = ObjectRef::new(5, 0);
pdf.replace_object(
f1_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let f1_1_font_ref = ObjectRef::new(6, 0);
pdf.replace_object(
f1_1_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, f1_font_ref));
font_dict.insert("F1_1", indirect(&mut pdf, f1_1_font_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf /F1_1_1 18 Tf");
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert!(font.get("F1").is_none());
assert_eq!(
font.get_ref("F1_1"),
Some(f1_font_ref),
"the renamed slot now holds F1's original value"
);
assert_eq!(
font.get_ref("F1_1_1"),
Some(f1_1_font_ref),
"the displaced original F1_1 value moved to the freshly minted name"
);
}
#[test]
fn adjust_appearance_stream_reuses_one_name_pool_for_multiple_conflicts() {
let mut pdf = open_minimal();
let f1_ref = ObjectRef::new(5, 0);
let f1_1_ref = ObjectRef::new(6, 0);
let f2_ref = ObjectRef::new(7, 0);
let f2_1_ref = ObjectRef::new(8, 0);
for object_ref in [f1_ref, f1_1_ref, f2_ref, f2_1_ref] {
pdf.replace_object(
object_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
}
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, f1_ref));
font_dict.insert("F1_1", indirect(&mut pdf, f1_1_ref));
font_dict.insert("F2", indirect(&mut pdf, f2_ref));
font_dict.insert("F2_1", indirect(&mut pdf, f2_1_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf /F2 18 Tf /F2_1 18 Tf",
);
let mut dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
dr_map.insert_rename(b"Font", b"F2".to_vec(), b"F2_1".to_vec());
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
filtered_stream_bytes(&stream),
b"/F1_1 18 Tf /F1_1_1 18 Tf /F2_1 18 Tf /F2_1_1 18 Tf"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.unwrap();
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(font.get_ref("F1_1"), Some(f1_ref));
assert_eq!(font.get_ref("F1_1_1"), Some(f1_1_ref));
assert_eq!(font.get_ref("F2_1"), Some(f2_ref));
assert_eq!(font.get_ref("F2_1_1"), Some(f2_1_ref));
}
#[test]
fn adjust_appearance_stream_double_conflict_same_object_is_noop() {
let mut pdf = open_minimal();
let shared_font_ref = ObjectRef::new(5, 0);
pdf.replace_object(
shared_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, shared_font_ref));
font_dict.insert("F1_1", indirect(&mut pdf, shared_font_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf /F1_1 18 Tf");
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert!(font.get("F1").is_none());
assert!(
font.get("F1_1_1").is_none(),
"no fresh name should be minted for a same-object collision"
);
assert_eq!(font.get_ref("F1_1"), Some(shared_font_ref));
}
#[test]
fn adjust_appearance_stream_unsupported_filter_is_non_fatal_noop() {
let mut pdf = open_minimal();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F2", HandleFixture::integer(1));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", HandleFixture::dictionary(resources)),
("Filter", HandleFixture::name(b"CCITTFaxDecode".to_vec())),
],
b"\x00\x01opaque-ccitt-bytes",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let result = adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map);
assert!(
result.is_ok(),
"an undecodable AP stream content must not fail the whole call"
);
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
stream_bytes(&stream),
b"\x00\x01opaque-ccitt-bytes",
"content bytes must be left exactly as read when they cannot be decoded"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get("F2").and_then(|value| value.as_integer()),
Some(1),
"unrelated existing key is untouched"
);
assert!(font.get("F1").is_none());
assert!(font.get("F1_1").is_none());
}
#[test]
fn adjust_appearance_stream_undecodable_filter_keeps_resources_rename_but_leaves_content_stale()
{
let mut pdf = open_minimal();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", HandleFixture::integer(1));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", HandleFixture::dictionary(resources)),
("Filter", HandleFixture::name(b"CCITTFaxDecode".to_vec())),
],
b"\x00\x01/F1 opaque-ccitt-bytes",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let result = adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map);
assert!(
result.is_ok(),
"an undecodable AP stream content must not fail the whole call"
);
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
stream_bytes(&stream),
b"\x00\x01/F1 opaque-ccitt-bytes",
"content bytes must be left exactly as read — qpdf does not roll \
back a rename it already applied to /Resources just because the \
later tokenize step failed"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get("F1_1").and_then(|value| value.as_integer()),
Some(1),
"the /Resources dict rename (steps 1-4) still applies even though \
the content (step 5) could not be rewritten"
);
assert!(font.get("F1").is_none());
}
#[test]
fn adjust_appearance_stream_leaves_lossy_filtered_content_byte_identical() {
let mut pdf = open_minimal();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", HandleFixture::integer(1));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let jpeg_like_bytes: &[u8] = b"\xff\xd8\xff\xe0not-real-jpeg-but-lossy-passthrough-bytes";
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", HandleFixture::dictionary(resources)),
("Filter", HandleFixture::name(b"DCTDecode".to_vec())),
],
jpeg_like_bytes,
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map)
.expect("a lossy-filtered AP stream must not fail the whole call");
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
stream_bytes(&stream),
jpeg_like_bytes,
"lossy/specialized-filtered content must stay byte-identical, \
not be treated as decoded and re-encoded"
);
assert_eq!(
stream_dict(&stream)
.get("Filter")
.and_then(|value| value.as_name()),
Some(b"DCTDecode".to_vec()),
"the filter must stay untouched since qpdf never installs a \
decode pipeline for it at this decode level"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get("F1_1").and_then(|value| value.as_integer()),
Some(1),
"the /Resources dict rename still applies independently of the \
(never attempted) content rewrite"
);
assert!(font.get("F1").is_none());
}
#[test]
fn adjust_appearance_stream_rename_chain_matches_qpdf_verified_result() {
let mut pdf = open_minimal();
let f1_font_ref = ObjectRef::new(5, 0);
pdf.replace_object(
f1_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let f1_1_font_ref = ObjectRef::new(6, 0);
pdf.replace_object(
f1_1_font_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, f1_font_ref));
font_dict.insert("F1_1", indirect(&mut pdf, f1_1_font_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf",
);
let mut dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
dr_map.insert_rename(b"Font", b"F1_1".to_vec(), b"F1_1_1".to_vec());
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf /F1_1_1 18 Tf");
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert!(font.get("F1").is_none());
assert_eq!(
font.get_ref("F1_1"),
Some(f1_1_font_ref),
"the true original F1_1 value re-lands under its OWN name via the re-merge"
);
assert_eq!(
font.get_ref("F1_1_1"),
Some(f1_font_ref),
"F1's value ends up under F1_1_1, having been reprocessed by the second rename entry"
);
}
#[test]
fn adjust_appearance_stream_reuses_existing_key_for_same_object_on_new_conflict() {
let mut pdf = open_minimal();
let shared_ref = ObjectRef::new(5, 0);
pdf.replace_object(
shared_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let other_ref = ObjectRef::new(6, 0);
pdf.replace_object(
other_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, shared_ref));
font_dict.insert("F2", indirect(&mut pdf, shared_ref));
font_dict.insert("F3", indirect(&mut pdf, other_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F3 18 Tf /F2 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F3", b"F2");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
filtered_stream_bytes(&stream),
b"/F2 18 Tf /F1 18 Tf",
"F3 (now under F2) rewrites to /F2; the original /F2 token must \
follow its displaced value to wherever it actually ended up (F1), \
not stay pointing at F2 (now a different object) or lose the rename"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(font.get_ref("F1"), Some(shared_ref));
assert_eq!(font.get_ref("F2"), Some(other_ref));
assert!(font.get("F3").is_none());
assert!(
font.get("F2_1").is_none(),
"no fresh name should be minted — the displaced value is REUSED \
under its existing F1 name, not aliased under a new one"
);
}
#[test]
fn adjust_appearance_stream_reuses_slot_vacated_earlier_in_same_merge() {
let mut pdf = open_minimal();
let shared_ref = ObjectRef::new(5, 0);
pdf.replace_object(
shared_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let temp_ref = ObjectRef::new(6, 0);
pdf.replace_object(temp_ref, HandleFixture::dictionary(HandleDictionary::new()))
.unwrap();
let other_ref = ObjectRef::new(7, 0);
pdf.replace_object(
other_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", indirect(&mut pdf, temp_ref));
font_dict.insert("F1_1", indirect(&mut pdf, shared_ref));
font_dict.insert("F2", indirect(&mut pdf, other_ref));
font_dict.insert("F4", indirect(&mut pdf, shared_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F4 12 Tf",
);
let mut dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
dr_map.insert_rename(b"Font", b"F1_1".to_vec(), b"F3".to_vec());
dr_map.insert_rename(b"Font", b"F2".to_vec(), b"F4".to_vec());
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
filtered_stream_bytes(&stream),
b"/F1_1 12 Tf",
"the /F4 token must follow shared_ref to wherever it actually \
ended up (F1_1, reused from the in-loop reinstate), not a \
freshly minted alias"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get_ref("F1_1"),
Some(shared_ref),
"the vacated slot's own verbatim reinstate"
);
assert_eq!(
font.get_ref("F4"),
Some(other_ref),
"F4's occupant is untouched — the reuse branch never mutates \
subdict, unlike the fresh-mint branch"
);
assert!(
font.get("F4_1").is_none(),
"no fresh alias minted for F4 — it reuses F1_1 by ObjectRef \
identity instead"
);
}
#[test]
fn adjust_appearance_stream_freezes_name_pool_with_identity_snapshot() {
let mut pdf = open_minimal();
let shared_ref = ObjectRef::new(5, 0);
let temp_a_ref = ObjectRef::new(6, 0);
let temp_b_ref = ObjectRef::new(7, 0);
let temp_c_ref = ObjectRef::new(8, 0);
let b_original_ref = ObjectRef::new(9, 0);
let c_original_ref = ObjectRef::new(10, 0);
for object_ref in [
shared_ref,
temp_a_ref,
temp_b_ref,
temp_c_ref,
c_original_ref,
] {
pdf.replace_object(
object_ref,
HandleFixture::dictionary(HandleDictionary::new()),
)
.unwrap();
}
let mut b_original = HandleDictionary::new();
b_original.insert("C_1", HandleFixture::name(b"Inserted".to_vec()));
pdf.replace_object(b_original_ref, HandleFixture::dictionary(b_original))
.unwrap();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F0", indirect(&mut pdf, shared_ref));
font_dict.insert("A", indirect(&mut pdf, shared_ref));
font_dict.insert("A0", indirect(&mut pdf, temp_a_ref));
font_dict.insert("A1", indirect(&mut pdf, temp_b_ref));
font_dict.insert("A2", indirect(&mut pdf, temp_c_ref));
font_dict.insert("B", indirect(&mut pdf, b_original_ref));
font_dict.insert("C", indirect(&mut pdf, c_original_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/C 12 Tf",
);
let mut dr_map = dr_map_with(b"Font", b"A0", b"A");
dr_map.insert_rename(b"Font", b"A1".to_vec(), b"B".to_vec());
dr_map.insert_rename(b"Font", b"A2".to_vec(), b"C".to_vec());
dr_map.insert_rename(b"Font", b"B".to_vec(), b"D".to_vec());
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
filtered_stream_bytes(&stream),
b"/C_1 12 Tf",
"the later fresh conflict must use the pool captured by the first conflict"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(font.get_ref("C_1"), Some(c_original_ref));
assert!(font.get("C_2").is_none());
}
#[test]
fn adjust_appearance_stream_tolerates_malformed_nested_resource_like_qpdf() {
let bodies: &[&[u8]] = &[
b"1 0 obj\n<< /Type /Catalog >>\nendobj\n",
b"2 0 obj\nnull\nendobj\n",
b"3 0 obj\nnull\nendobj\n",
b"4 0 obj\nnull\nendobj\n",
b"5 0 obj\nnull\nendobj\n",
b"6 0 obj\nnull\nendobj\n",
b"7 0 obj\nnull\nendobj\n",
b"8 0 obj\n<<",
];
let mut bytes = b"%PDF-1.7\n".to_vec();
let mut offsets = Vec::new();
for body in bodies {
offsets.push(bytes.len() as u64);
bytes.extend_from_slice(body);
}
let xref_start = bytes.len();
bytes.extend_from_slice(b"xref\n0 9\n0000000000 65535 f \n");
for offset in offsets {
bytes.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
}
bytes.extend_from_slice(
format!("trailer\n<< /Size 9 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open_with_options(
Cursor::new(bytes),
PdfOpenOptions {
repair: false,
..PdfOpenOptions::default()
},
)
.expect("malformed object must stay lazy");
let broken_ref = indirect(&mut pdf, ObjectRef::new(8, 0));
let broken_resource_ref = set_dict(&mut pdf, 5, &[("Broken", broken_ref)]);
let f1_ref = set_dict(&mut pdf, 6, &[]);
let f1_1_ref = set_dict(&mut pdf, 7, &[]);
let mut font_dict = HandleDictionary::new();
font_dict.insert("F0", indirect(&mut pdf, broken_resource_ref));
font_dict.insert("F1", indirect(&mut pdf, f1_ref));
font_dict.insert("F1_1", indirect(&mut pdf, f1_1_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map)
.expect("a malformed object two levels below the touched category must not fail");
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(
filtered_stream_bytes(&stream),
b"/F1_1 18 Tf",
"the rename must actually apply to the stream content"
);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get_ref("F1_1"),
Some(f1_ref),
"F1's value must move into the F1_1 slot"
);
assert!(font.get("F1").is_none(), "F1 must be removed after rename");
assert_eq!(
font.get_ref("F0"),
Some(broken_resource_ref),
"F0 is untouched by the rename and its malformed grandchild is never dereferenced"
);
}
#[test]
fn adjust_appearance_stream_unrelated_nested_resource_does_not_interfere_with_rename() {
let mut pdf = open_minimal();
let nested_value_ref = set_dict(&mut pdf, 8, &[]);
let nested_value = indirect(&mut pdf, nested_value_ref);
let nested_resource_ref = set_dict(&mut pdf, 9, &[("Nested", nested_value)]);
let f1_ref = set_dict(&mut pdf, 6, &[]);
let f1_1_ref = set_dict(&mut pdf, 7, &[]);
let mut font_dict = HandleDictionary::new();
font_dict.insert("F0", indirect(&mut pdf, nested_resource_ref));
font_dict.insert("F1", indirect(&mut pdf, f1_ref));
font_dict.insert("F1_1", indirect(&mut pdf, f1_1_ref));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", HandleFixture::dictionary(resources))],
b"/F1 18 Tf",
);
adjust_appearance_stream_via_handle(
&mut pdf,
ap_ref,
&dr_map_with(b"Font", b"F1", b"F1_1"),
)
.unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
assert_eq!(filtered_stream_bytes(&stream), b"/F1_1 18 Tf");
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get_ref("F0"),
Some(nested_resource_ref),
"the unrelated F0 entry is untouched by the F1->F1_1 rename"
);
}
fn pack_lzw_9bit_literal(bytes: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut buf: u32 = 0;
let mut bits: u32 = 0;
let mut codes: Vec<u16> = bytes.iter().map(|&b| u16::from(b)).collect();
codes.push(257); for code in codes {
buf = (buf << 9) | u32::from(code);
bits += 9;
while bits >= 8 {
bits -= 8;
out.push((buf >> bits) as u8);
}
}
if bits > 0 {
out.push((buf << (8 - bits)) as u8);
}
out
}
#[test]
fn adjust_appearance_stream_lzw_keeps_the_source_filter_and_attaches_a_filter() {
let mut pdf = open_minimal();
let mut font_dict = HandleDictionary::new();
font_dict.insert("F1", HandleFixture::integer(1));
let mut resources = HandleDictionary::new();
resources.insert("Font", HandleFixture::dictionary(font_dict));
let lzw_bytes = pack_lzw_9bit_literal(b"/F1 18 Tf");
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", HandleFixture::dictionary(resources)),
("Filter", HandleFixture::name(b"LZWDecode".to_vec())),
],
&lzw_bytes,
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream_via_handle(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = stream_handle(&mut pdf, ap_ref);
let resources = stream_dict(&stream)
.get("Resources")
.and_then(handle_dictionary)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(handle_dictionary).unwrap();
assert_eq!(
font.get("F1_1").and_then(|value| value.as_integer()),
Some(1)
);
assert!(font.get("F1").is_none());
assert_eq!(
stream_dict(&stream)
.get("Filter")
.and_then(|value| value.as_name()),
Some(b"LZWDecode".to_vec()),
"qpdf keeps the source filter when only a token filter is attached"
);
assert!(
stream_dict(&stream).get("DecodeParms").is_none(),
"the source stream's absent DecodeParms entry must remain absent"
);
assert_eq!(stream_bytes(&stream), lzw_bytes);
let decoded_content = stream
.get_stream_data(crate::writer::DecodeLevel::All)
.unwrap();
assert_eq!(
decoded_content.as_slice(),
b"/F1_1 18 Tf",
"content must reference the RENAMED name, consistent with /Resources"
);
assert_eq!(
stream_dict(&stream)
.get("Length")
.and_then(|value| value.as_integer()),
None,
"/Length must remain absent until the writer emits the filtered stream"
);
}
}