use crate::object_handle::{ObjectHandle, ObjectValue};
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::{Error, ObjectRef, Pdf, Result};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek};
const OBJECT_COPY_STACK_RED_ZONE: usize = 32 * 1024;
const OBJECT_COPY_STACK_GROWTH_SIZE: usize = 1024 * 1024;
pub(crate) fn copy_foreign_object<R: Read + Seek>(
target: &mut Pdf<R>,
foreign: &ObjectHandle,
) -> Result<ObjectHandle> {
copy_foreign_object_with_stale_generation_policy(target, foreign, false)
}
pub(crate) fn copy_foreign_object_with_stale_generation_policy<R: Read + Seek>(
target: &mut Pdf<R>,
foreign: &ObjectHandle,
remove_stale_generations: bool,
) -> Result<ObjectHandle> {
if !foreign.is_indirect() {
return Err(Error::System(
"QPDF::copyForeign called with direct object handle".to_owned(),
));
}
let source_id = foreign.owning_pdf_unique_id().ok_or_else(|| {
Error::System("QPDF::copyForeign called with object with no owning PDF".to_owned())
})?;
if source_id == target.unique_id() {
return Err(Error::System(
"QPDF::copyForeign called with object from this QPDF".to_owned(),
));
}
copy_foreign_with_source_id(
target,
source_id,
foreign,
true,
true,
remove_stale_generations,
)
}
pub(crate) fn copy_foreign_object_for_preserve<R: Read + Seek>(
target: &mut Pdf<R>,
foreign: &ObjectHandle,
) -> Result<ObjectHandle> {
if !foreign.is_indirect() {
return Err(Error::System(
"QPDF::copyForeign called with direct object handle".to_owned(),
));
}
let source_id = foreign.owning_pdf_unique_id().ok_or_else(|| {
Error::System("QPDF::copyForeign called with object with no owning PDF".to_owned())
})?;
if source_id == target.unique_id() {
return Err(Error::System(
"QPDF::copyForeign called with object from this QPDF".to_owned(),
));
}
copy_foreign_with_source_id(target, source_id, foreign, true, false, false)
}
pub(crate) fn copy_foreign_value<R: Read + Seek>(
target: &mut Pdf<R>,
source_id: u64,
foreign: &ObjectHandle,
) -> Result<ObjectHandle> {
copy_foreign_value_with_stale_generation_policy(target, source_id, foreign, false)
}
pub(crate) fn copy_foreign_value_with_stale_generation_policy<R: Read + Seek>(
target: &mut Pdf<R>,
source_id: u64,
foreign: &ObjectHandle,
remove_stale_generations: bool,
) -> Result<ObjectHandle> {
if source_id == target.unique_id() {
return Err(Error::System(
"QPDF::copyForeign called with object from this QPDF".to_owned(),
));
}
if let Some(owner_id) = foreign.owning_pdf_unique_id() {
if owner_id != source_id {
return Err(Error::System(
"QPDF::copyForeign encountered an object owned by a different document".to_owned(),
));
}
}
copy_foreign_with_source_id(
target,
source_id,
foreign,
false,
true,
remove_stale_generations,
)
}
#[allow(deprecated)]
fn copy_foreign_with_source_id<R: Read + Seek>(
target: &mut Pdf<R>,
source_id: u64,
foreign: &ObjectHandle,
require_indirect: bool,
stop_at_page_tree: bool,
remove_stale_generations: bool,
) -> Result<ObjectHandle> {
let object_map = target.take_foreign_object_map(source_id);
let visiting = target.take_foreign_object_visiting(source_id);
if !visiting.is_empty() {
target.set_foreign_object_map(source_id, object_map);
target.set_foreign_object_visiting(source_id, visiting);
return Err(Error::Internal(
"obj_copier.visiting is not empty at the beginning of copyForeignObject".to_owned(),
));
}
let to_copy = target.take_foreign_object_to_copy(source_id);
let mut copier = ForeignObjectCopier {
target,
source_id,
object_map,
visiting,
direct_visiting: Vec::new(),
stop_at_page_tree,
remove_stale_generations,
to_copy,
};
let result = if require_indirect {
copier.run(foreign)
} else {
copier.run_value(foreign)
};
let object_map = copier.object_map;
let visiting = copier.visiting;
let to_copy = copier.to_copy;
copier.target.set_foreign_object_map(source_id, object_map);
copier
.target
.set_foreign_object_visiting(source_id, visiting);
copier.target.set_foreign_object_to_copy(source_id, to_copy);
result
}
struct ForeignObjectCopier<'a, R: Read + Seek + 'static> {
target: &'a mut Pdf<R>,
source_id: u64,
object_map: BTreeMap<QpdfObjGen, ObjectRef>,
visiting: BTreeSet<QpdfObjGen>,
#[deprecated(
note = "no qpdf counterpart; direct-cycle guard for graphs only constructible via ObjectHandle::replace_key -- do not add new callers"
)]
direct_visiting: Vec<ObjectHandle>,
stop_at_page_tree: bool,
remove_stale_generations: bool,
to_copy: Vec<ObjectHandle>,
}
impl<R: Read + Seek + 'static> ForeignObjectCopier<'_, R> {
fn run(&mut self, foreign: &ObjectHandle) -> Result<ObjectHandle> {
self.run_value_inner(foreign, true)
}
fn run_value(&mut self, foreign: &ObjectHandle) -> Result<ObjectHandle> {
self.run_value_inner(foreign, false)
}
fn run_value_inner(
&mut self,
foreign: &ObjectHandle,
require_indirect: bool,
) -> Result<ObjectHandle> {
self.reserve_objects(foreign.clone(), true)?;
if !self.visiting.is_empty() {
return Err(Error::Internal(
"foreign object copier retained a visiting object".to_owned(),
));
}
let pending = self.to_copy.len();
for index in 0..pending {
let source = self.to_copy[index].clone();
let source_object_gen = source
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| {
Error::Internal("foreign copier queued a direct object".to_owned())
})?;
let replacement = self.replace_foreign_indirect_objects(source.clone(), true)?;
if source.as_stream_dict().is_none() {
let target_ref = *self.object_map.get(&source_object_gen).ok_or_else(|| {
Error::Internal(
"foreign copier reservation missing for a queued object".to_owned(),
)
})?;
self.target
.resolver
.replace_object(target_ref, replacement)?;
}
}
self.to_copy.clear();
if let Some(source_object_gen) = foreign
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
let Some(&target_ref) = self.object_map.get(&source_object_gen) else {
self.target.resolver.push_damaged_warning(
"unexpected reference to /Pages object while copying foreign object; replacing with null",
)?;
return Ok(ObjectHandle::null());
};
return Ok(self.target.get_object_handle(target_ref));
}
if require_indirect {
return Err(Error::System(
"QPDF::copyForeign called with direct object handle".to_owned(),
));
}
self.replace_foreign_indirect_objects(foreign.clone(), true)
}
fn reserve_objects(&mut self, foreign: ObjectHandle, top: bool) -> Result<()> {
stacker::maybe_grow(
OBJECT_COPY_STACK_RED_ZONE,
OBJECT_COPY_STACK_GROWTH_SIZE,
|| self.reserve_objects_inner(foreign, top),
)
}
#[allow(deprecated)]
fn reserve_objects_inner(&mut self, foreign: ObjectHandle, top: bool) -> Result<()> {
foreign.try_dereference()?;
if self.remove_stale_generations
&& !top
&& foreign.is_null()
&& foreign.has_newer_cached_generation()
{
return Ok(());
}
if foreign.is_reserved() {
return Err(Error::System(
"QPDF: attempting to copy a foreign reserved object".to_owned(),
));
}
if let Some(owner_id) = foreign.owning_pdf_unique_id() {
if owner_id != self.source_id {
return Err(Error::System(
"QPDF::copyForeign encountered an object owned by a different document"
.to_owned(),
));
}
}
if self.stop_at_page_tree && foreign.try_is_dictionary_of_type(b"Pages", b"")? {
return Ok(());
}
if let Some(source_object_gen) = foreign
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
let is_page = foreign.try_is_dictionary_of_type(b"Page", b"")?;
let is_stream = foreign.as_stream_dict().is_some();
if self.visiting.contains(&source_object_gen) {
return Ok(());
}
if let Some(&existing_target_ref) = self.object_map.get(&source_object_gen) {
let mapped = self.target.get_object_handle(existing_target_ref);
if !(top && is_page && mapped.is_null()) {
return Ok(());
}
} else {
let mapped = if is_stream {
self.target.new_stream()?
} else {
self.target
.make_indirect_from_object_handle(ObjectHandle::null())?
};
let target_ref = mapped.object_ref().ok_or_else(|| {
Error::Internal("foreign copier created a direct reservation".to_owned())
})?;
self.object_map.insert(source_object_gen, target_ref);
}
self.visiting.insert(source_object_gen);
if !top && is_page {
self.visiting.remove(&source_object_gen);
return Ok(());
}
self.to_copy.push(foreign.clone());
self.reserve_children(&foreign)?;
self.visiting.remove(&source_object_gen);
return Ok(());
}
if self
.direct_visiting
.iter()
.any(|active| active.is_same_object_as(&foreign))
{
return Ok(());
}
self.direct_visiting.push(foreign.clone());
let result = self.reserve_children(&foreign);
self.direct_visiting.pop();
result
}
fn reserve_children(&mut self, foreign: &ObjectHandle) -> Result<()> {
if let Some(items) = foreign.as_array() {
for item in items {
self.reserve_objects(item, false)?;
}
} else if let Some(entries) = foreign.as_dictionary() {
for (_, item) in entries {
if item.try_is_null()? {
continue;
}
self.reserve_objects(item, false)?;
}
} else if let Some(dictionary) = foreign.as_stream_dict() {
self.reserve_objects(dictionary, false)?;
}
Ok(())
}
fn replace_foreign_indirect_objects(
&mut self,
foreign: ObjectHandle,
top: bool,
) -> Result<ObjectHandle> {
stacker::maybe_grow(
OBJECT_COPY_STACK_RED_ZONE,
OBJECT_COPY_STACK_GROWTH_SIZE,
|| self.replace_foreign_indirect_objects_inner(foreign, top),
)
}
#[allow(deprecated)]
fn replace_foreign_indirect_objects_inner(
&mut self,
foreign: ObjectHandle,
top: bool,
) -> Result<ObjectHandle> {
foreign.try_dereference()?;
if !top {
if let Some(source_object_gen) = foreign
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
return Ok(self
.object_map
.get(&source_object_gen)
.map(|target_ref| self.target.get_object_handle(*target_ref))
.unwrap_or_else(ObjectHandle::null));
}
}
if foreign
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.is_none()
{
if self
.direct_visiting
.iter()
.any(|active| active.is_same_object_as(&foreign))
{
return Err(Error::System(
"QPDF::copyForeign encountered a direct object cycle".to_owned(),
));
}
self.direct_visiting.push(foreign.clone());
let result = self.replace_foreign_value(foreign);
self.direct_visiting.pop();
return result;
}
self.replace_foreign_value(foreign)
}
fn replace_foreign_value(&mut self, foreign: ObjectHandle) -> Result<ObjectHandle> {
if let Some(source_dictionary) = foreign.as_stream_dict() {
if !foreign.is_indirect() {
return Err(Error::System(
"QPDF::copyForeign encountered a direct stream object".to_owned(),
));
}
let source_object_gen = foreign
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| {
Error::Internal("foreign stream has no indirect identity".to_owned())
})?;
let target_ref = *self.object_map.get(&source_object_gen).ok_or_else(|| {
Error::Internal("foreign stream reservation is missing".to_owned())
})?;
let destination = self.target.get_object_handle(target_ref);
let destination_dictionary = destination.as_stream_dict().ok_or_else(|| {
Error::Internal("foreign stream reservation is not a stream".to_owned())
})?;
for (key, value) in source_dictionary.as_dictionary().unwrap_or_default() {
if value.try_is_null()? {
continue;
}
let replacement = self.replace_foreign_indirect_objects(value, false)?;
destination_dictionary.replace_key(&key, replacement)?;
}
self.target
.resolver
.copy_stream_data(&destination, &foreign)?;
return Ok(destination);
}
if let Some(items) = foreign.as_array() {
let mut copied = Vec::with_capacity(items.len());
for item in items {
copied.push(self.replace_foreign_indirect_objects(item, false)?);
}
return Ok(self
.target
.resolver
.direct_object_handle(ObjectValue::Array(copied)));
}
if let Some(entries) = foreign.as_dictionary() {
let copied = self
.target
.resolver
.direct_object_handle(ObjectValue::Dictionary(BTreeMap::new()));
for (key, value) in entries {
if value.try_is_null()? {
continue;
}
let replacement = self.replace_foreign_indirect_objects(value, false)?;
copied.replace_key(&key, replacement)?;
}
return Ok(copied);
}
let direct = foreign.shallow_copy()?;
let value = direct.direct_value_clone()?.ok_or_else(|| {
Error::Internal("foreign scalar copy did not produce a direct value".to_owned())
})?;
Ok(self.target.resolver.direct_object_handle(value))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{ObjectHandle, ObjectStreamMode, PdfWriter};
use std::io::Cursor;
use std::rc::Rc;
fn minimal_pdf() -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = b"%PDF-1.4\n".to_vec();
let off1 = bytes.len();
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = bytes.len();
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = bytes.len();
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref = bytes.len();
bytes.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \ntrailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
Pdf::open(Cursor::new(bytes)).unwrap()
}
fn pdf_with_stream(data: &[u8]) -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = b"%PDF-1.4\n".to_vec();
let off1 = bytes.len();
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = bytes.len();
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = bytes.len();
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off4 = bytes.len();
bytes.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", data.len()).as_bytes(),
);
bytes.extend_from_slice(data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let xref = bytes.len();
bytes.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \ntrailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
Pdf::open(Cursor::new(bytes)).unwrap()
}
#[test]
fn copy_foreign_object_preserves_shared_children_and_cycles() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let shared = source
.make_indirect_object_handle(ObjectHandle::integer(7))
.expect("shared child");
let first = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("first cycle node");
let second = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("second cycle node");
first.replace_key(b"/Next", second.clone()).unwrap();
second.replace_key(b"/Next", first.clone()).unwrap();
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/SharedA", shared.clone()).unwrap();
root.replace_key(b"/SharedB", shared.clone()).unwrap();
root.replace_key(b"/Cycle", first.clone()).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy foreign object");
let copied_again = target
.copy_foreign_object(&root)
.expect("reuse foreign object map");
assert!(copied.is_same_object_as(&copied_again));
let copied_shared_a = copied.try_get_key(b"/SharedA").unwrap();
let copied_shared_b = copied.try_get_key(b"/SharedB").unwrap();
assert!(copied_shared_a.is_same_object_as(&copied_shared_b));
assert_ne!(copied_shared_a.object_ref(), shared.object_ref());
let copied_first = copied.try_get_key(b"/Cycle").unwrap();
let copied_second = copied_first.try_get_key(b"/Next").unwrap();
assert_eq!(
copied_second.try_get_key(b"/Next").unwrap().object_ref(),
copied_first.object_ref()
);
}
#[test]
fn copy_foreign_object_matches_qpdf_input_classification_and_pages_boundary() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let direct_error = target
.copy_foreign_object(&ObjectHandle::integer(1))
.expect_err("direct input must be rejected");
assert!(matches!(direct_error, Error::System(message)
if message == "QPDF::copyForeign called with direct object handle"));
let owned = target.get_object_handle(ObjectRef::new(3, 0));
let owned_error = target
.copy_foreign_object(&owned)
.expect_err("destination-owned input must be rejected");
assert!(matches!(owned_error, Error::System(message)
if message == "QPDF::copyForeign called with object from this QPDF"));
let pages = source.get_object_handle(ObjectRef::new(2, 0));
let copied_pages = target
.copy_foreign_object(&pages)
.expect("Pages boundary is a warning/null result");
assert!(copied_pages.is_null());
assert!(target
.repair_diagnostics()
.entries()
.iter()
.any(|diagnostic| diagnostic
.message_string()
.contains("unexpected reference to /Pages object while copying foreign object")));
}
#[test]
fn copy_foreign_object_preserves_a_raw_generation_identity() {
let raw_ref = ObjectRef::new(5, 65_535);
let mut source = minimal_pdf();
source
.replace_object(raw_ref, ObjectHandle::integer(45))
.expect("install raw-generation source value");
let raw = source.get_object_handle(raw_ref);
let mut target = minimal_pdf();
let copied = target
.copy_foreign_object(&raw)
.expect("raw-generation foreign object is indirect to qpdf");
let copied_again = target
.copy_foreign_object(&raw)
.expect("raw-generation map entry is persistent");
assert!(copied.is_indirect());
assert!(copied.is_same_object_as(&copied_again));
assert_eq!(copied.try_as_integer().unwrap(), Some(45));
}
#[test]
fn copy_foreign_stream_preserves_a_raw_generation_identity() {
let raw_ref = ObjectRef::new(5, 65_535);
let mut source = minimal_pdf();
source
.replace_object(
raw_ref,
ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(4))]),
Rc::new(b"data".to_vec()),
),
)
.expect("install raw-generation source stream");
let raw = source.get_object_handle(raw_ref);
let mut target = minimal_pdf();
let copied = target
.copy_foreign_object(&raw)
.expect("raw-generation foreign stream is indirect to qpdf");
assert!(copied.is_indirect());
assert!(copied.as_stream_dict().is_some());
}
#[test]
fn preserve_copy_allows_page_tree_containers_without_pages_boundary_warning() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let direct_error = copy_foreign_object_for_preserve(&mut target, &ObjectHandle::integer(1))
.expect_err("preserve copy must reject a direct object");
assert!(matches!(direct_error, Error::System(message)
if message == "QPDF::copyForeign called with direct object handle"));
let unowned = ObjectHandle::new_indirect_unresolved(ObjectRef::new(99, 0), -1);
let unowned_error = copy_foreign_object_for_preserve(&mut target, &unowned)
.expect_err("preserve copy must reject an unowned indirect object");
assert!(matches!(unowned_error, Error::System(message)
if message == "QPDF::copyForeign called with object with no owning PDF"));
let owned = target.get_object_handle(ObjectRef::new(3, 0));
let same_document_error = copy_foreign_object_for_preserve(&mut target, &owned)
.expect_err("preserve copy must reject a target-owned object");
assert!(matches!(same_document_error, Error::System(message)
if message == "QPDF::copyForeign called with object from this QPDF"));
let page = source.get_object_handle(ObjectRef::new(3, 0));
let intermediate = source
.make_indirect_object_handle(ObjectHandle::dictionary(vec![
(b"Type".to_vec(), ObjectHandle::name(b"Pages".to_vec())),
(b"Kids".to_vec(), ObjectHandle::array(vec![page])),
(b"Count".to_vec(), ObjectHandle::integer(1)),
]))
.expect("intermediate page tree node");
source
.get_object_handle(ObjectRef::new(2, 0))
.replace_key(b"Kids", ObjectHandle::array(vec![intermediate.clone()]))
.expect("replace page-tree children");
let copied = copy_foreign_object_for_preserve(&mut target, &intermediate)
.expect("preserve traversal must copy a page-tree container");
assert!(copied.object_ref().is_some());
copied.try_is_scalar().expect("resolve preserved page tree");
assert!(target.repair_diagnostics().entries().is_empty());
assert_eq!(
copied
.try_get_key(b"/Kids")
.unwrap()
.try_array_len()
.unwrap(),
Some(1)
);
}
#[test]
fn copy_foreign_object_omits_indirect_null_dictionary_keys_like_qpdf_get_keys() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let target_refs_before = target.canonical_object_refs();
let indirect_null = source
.make_indirect_object_handle(ObjectHandle::null())
.expect("indirect null");
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/IndirectNull", indirect_null)
.expect("attach indirect null");
let copied = target
.copy_foreign_object(&root)
.expect("copy dictionary with an indirect null entry");
assert!(!copied.try_has_key(b"/IndirectNull").unwrap());
assert_eq!(
target.canonical_object_refs().len(),
target_refs_before.len() + 1,
"qpdf getKeys excludes the null child before reservation"
);
}
#[test]
fn copy_foreign_stream_omits_indirect_null_dictionary_keys_like_qpdf_get_keys() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let target_refs_before = target.canonical_object_refs();
let indirect_null = source
.make_indirect_object_handle(ObjectHandle::null())
.expect("indirect null");
let stream = source.new_stream().expect("stream");
stream
.as_stream_dict()
.expect("stream dictionary")
.replace_key(b"/IndirectNull", indirect_null)
.expect("attach indirect null");
let copied = target
.copy_foreign_object(&stream)
.expect("copy stream with an indirect null dictionary entry");
assert!(!copied
.as_stream_dict()
.expect("copied stream dictionary")
.try_has_key(b"/IndirectNull")
.unwrap());
assert_eq!(
target.canonical_object_refs().len(),
target_refs_before.len() + 1,
"qpdf getKeys excludes the null stream-dictionary child before reservation"
);
}
#[test]
#[allow(deprecated)]
fn replace_foreign_stream_omits_indirect_null_dictionary_keys_like_qpdf_get_keys() {
let mut source = minimal_pdf();
let indirect_null = source
.make_indirect_object_handle(ObjectHandle::null())
.expect("indirect null");
let source_stream = source.new_stream().expect("source stream");
source_stream
.as_stream_dict()
.expect("source stream dictionary")
.replace_key(b"/IndirectNull", indirect_null.clone())
.expect("attach indirect null");
assert!(source_stream
.as_stream_dict()
.expect("source stream dictionary")
.try_get_key(b"/IndirectNull")
.expect("read source stream dictionary entry")
.is_null());
let mut target = minimal_pdf();
let target_stream = target.new_stream().expect("target stream");
let target_value = target
.make_indirect_object_handle(ObjectHandle::integer(7))
.expect("target replacement");
let source_stream_ref = source_stream
.qpdf_obj_gen()
.expect("source stream identity");
let source_null_ref = indirect_null.qpdf_obj_gen().expect("source null identity");
let target_stream_ref = target_stream.object_ref().expect("target stream identity");
let target_value_ref = target_value.object_ref().expect("target value identity");
let copied = {
let mut copier = ForeignObjectCopier {
target: &mut target,
source_id: source.unique_id(),
object_map: BTreeMap::from([
(source_stream_ref, target_stream_ref),
(source_null_ref, target_value_ref),
]),
visiting: BTreeSet::new(),
direct_visiting: Vec::new(),
stop_at_page_tree: true,
remove_stale_generations: false,
to_copy: Vec::new(),
};
copier
.replace_foreign_indirect_objects(source_stream, true)
.expect("replace foreign stream")
};
assert!(!copied
.as_stream_dict()
.expect("copied stream dictionary")
.try_has_key(b"/IndirectNull")
.unwrap());
}
#[test]
fn copy_foreign_object_rejects_a_foreign_reserved_object_before_reservation() {
let source = minimal_pdf();
let mut target = minimal_pdf();
let reserved = source
.new_reserved()
.expect("source reserved construction sentinel");
let target_refs_before = target.canonical_object_refs();
let error = target
.copy_foreign_object(&reserved)
.expect_err("qpdf rejects a foreign reserved object during reservation");
assert!(matches!(error, Error::System(message)
if message == "QPDF: attempting to copy a foreign reserved object"));
assert_eq!(target.canonical_object_refs(), target_refs_before);
}
#[allow(deprecated)]
fn empty_copier<'a>(
target: &'a mut Pdf<Cursor<Vec<u8>>>,
) -> ForeignObjectCopier<'a, Cursor<Vec<u8>>> {
ForeignObjectCopier {
target,
source_id: 0,
object_map: BTreeMap::new(),
visiting: BTreeSet::new(),
direct_visiting: Vec::new(),
stop_at_page_tree: true,
remove_stale_generations: false,
to_copy: Vec::new(),
}
}
#[test]
fn foreign_copier_defensive_invariants_are_reported() {
let error = {
let mut target = minimal_pdf();
let mut copier = empty_copier(&mut target);
copier.visiting.insert(QpdfObjGen::new(900, 0));
copier
.run(&ObjectHandle::integer(1))
.expect_err("a stale visiting set must be rejected")
};
assert!(matches!(error, Error::Internal(message)
if message == "foreign object copier retained a visiting object"));
let error = {
let mut target = minimal_pdf();
let mut copier = empty_copier(&mut target);
copier.to_copy.push(ObjectHandle::integer(1));
copier
.run(&ObjectHandle::integer(2))
.expect_err("a direct queued object must be rejected")
};
assert!(matches!(error, Error::Internal(message)
if message == "foreign copier queued a direct object"));
let error = {
let mut target = minimal_pdf();
let mut copier = empty_copier(&mut target);
copier
.run(&ObjectHandle::integer(3))
.expect_err("a direct copier root must be rejected")
};
assert!(matches!(error, Error::System(message)
if message == "QPDF::copyForeign called with direct object handle"));
}
#[test]
#[allow(deprecated)]
fn foreign_copier_stops_reservation_on_a_direct_identity_cycle() {
let direct = ObjectHandle::dictionary(Vec::new());
direct.replace_key(b"/Self", direct.clone()).unwrap();
let mut target = minimal_pdf();
let mut copier = empty_copier(&mut target);
copier.direct_visiting.push(direct.clone());
copier
.reserve_objects(direct, true)
.expect("direct identity cycles are bounded during reservation");
}
#[test]
fn copy_foreign_object_rejects_a_direct_identity_cycle_during_replacement() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let a = ObjectHandle::dictionary(Vec::new());
let b = ObjectHandle::dictionary(Vec::new());
a.replace_key(b"/B", b.clone()).unwrap();
b.replace_key(b"/A", a.clone()).unwrap();
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/A", a).unwrap();
let error = target
.copy_foreign_object(&root)
.expect_err("a direct identity cycle must not recurse unbounded during replacement");
assert!(matches!(error, Error::System(message)
if message == "QPDF::copyForeign encountered a direct object cycle"));
}
#[test]
fn copy_foreign_object_rejects_a_direct_stream_child() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(Vec::new()),
Rc::new(b"direct stream".to_vec()),
);
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", direct_stream).unwrap();
let error = target
.copy_foreign_object(&root)
.expect_err("a direct stream has no qpdf foreign-copy route");
assert!(matches!(error, Error::System(message)
if message == "QPDF::copyForeign encountered a direct stream object"));
}
#[test]
fn copy_foreign_object_retries_a_failed_stream_replacement() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(Vec::new()),
Rc::new(b"direct stream".to_vec()),
);
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(vec![(
b"/Stream".to_vec(),
direct_stream,
)]))
.expect("root");
let first_error = target
.copy_foreign_object(&root)
.expect_err("the direct stream must fail during replacement");
assert!(matches!(&first_error, Error::System(message)
if message == "QPDF::copyForeign encountered a direct stream object"));
let retry_error = target
.copy_foreign_object(&root)
.expect_err("the failed stream replacement must remain queued for retry");
assert!(matches!(retry_error, Error::System(message)
if message == "QPDF::copyForeign encountered a direct stream object"));
}
#[test]
#[allow(deprecated)]
fn foreign_copier_rejects_a_non_stream_destination_reservation() {
let source = minimal_pdf();
let source_stream = source.new_stream().expect("source stream");
let source_ref = source_stream
.qpdf_obj_gen()
.expect("source stream identity");
let mut target = minimal_pdf();
let wrong_destination = target
.make_indirect_object_handle(ObjectHandle::integer(7))
.expect("wrong destination");
let wrong_ref = wrong_destination
.object_ref()
.expect("wrong destination identity");
let error = {
let mut copier = ForeignObjectCopier {
target: &mut target,
source_id: source.unique_id(),
object_map: BTreeMap::from([(source_ref, wrong_ref)]),
visiting: BTreeSet::new(),
direct_visiting: Vec::new(),
stop_at_page_tree: true,
remove_stale_generations: false,
to_copy: Vec::new(),
};
copier
.replace_foreign_indirect_objects(source_stream, true)
.expect_err("a stream must map to a stream destination")
};
assert!(matches!(error, Error::Internal(message)
if message == "foreign stream reservation is not a stream"));
}
#[test]
fn copy_foreign_object_rejects_an_unowned_indirect_handle() {
let mut target = minimal_pdf();
let unowned = ObjectHandle::new_indirect_unresolved(ObjectRef::new(99, 0), -1);
let error = target
.copy_foreign_object(&unowned)
.expect_err("an indirect handle without an owning PDF must be rejected");
assert!(matches!(error, Error::System(message)
if message == "QPDF::copyForeign called with object with no owning PDF"));
}
#[test]
fn copy_foreign_object_rejects_a_child_owned_by_a_different_document() {
let mut source = minimal_pdf();
let mut other_source = minimal_pdf();
let mut target = minimal_pdf();
let foreign_child = other_source.get_object_handle(ObjectRef::new(1, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(vec![(
b"/Foreign".to_vec(),
foreign_child,
)]))
.expect("root");
let error = target
.copy_foreign_object(&root)
.expect_err("a child owned by a different document than the root must be rejected");
assert!(matches!(error, Error::System(message)
if message == "QPDF::copyForeign encountered an object owned by a different document"));
}
#[test]
fn copy_foreign_object_poisons_retry_after_a_reservation_phase_failure() {
let mut source = minimal_pdf();
let mut other_source = minimal_pdf();
let mut target = minimal_pdf();
let foreign_child = other_source.get_object_handle(ObjectRef::new(1, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(vec![(
b"/Foreign".to_vec(),
foreign_child,
)]))
.expect("root");
let first_error = target
.copy_foreign_object(&root)
.expect_err("a child owned by a different document than the root must be rejected");
assert!(matches!(&first_error, Error::System(message)
if message == "QPDF::copyForeign encountered an object owned by a different document"));
let retry_error = target
.copy_foreign_object(&root)
.expect_err("a source poisoned by a reservation-phase failure must stay rejected");
assert!(matches!(retry_error, Error::Internal(message)
if message == "obj_copier.visiting is not empty at the beginning of copyForeignObject"));
}
#[test]
fn copy_foreign_object_stops_at_nested_page_boundaries() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let hidden = source
.make_indirect_object_handle(ObjectHandle::integer(99))
.expect("hidden page child");
let page = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("nested page");
page.replace_key(b"/Type", ObjectHandle::name(b"Page".to_vec()))
.unwrap();
page.replace_key(b"/Hidden", hidden.clone()).unwrap();
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Page", page.clone()).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy root with nested page");
let copied_page = copied.try_get_key(b"/Page").unwrap();
assert!(copied_page.is_null());
assert!(copied_page.object_ref().is_some());
assert!(!target
.canonical_object_refs()
.iter()
.any(|object_ref| *object_ref != ObjectRef::new(1, 0)
&& target.get_object_handle(*object_ref).as_integer() == Some(99)));
}
#[test]
fn copy_foreign_object_recopies_a_nested_page_when_it_becomes_top_level() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let page = source.get_object_handle(ObjectRef::new(3, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Page", page.clone()).unwrap();
let copied_root = target
.copy_foreign_object(&root)
.expect("copy root with nested page boundary");
let boundary_page = copied_root.try_get_key(b"/Page").unwrap();
assert!(boundary_page.is_null());
assert!(boundary_page.is_indirect());
let copied_page = target
.copy_foreign_object(&page)
.expect("copy page as a top-level object");
assert!(copied_page.is_same_object_as(&boundary_page));
assert!(!copied_page.is_null());
assert_eq!(
copied_page.try_get_key(b"/Type").unwrap().as_name(),
Some(b"Page".to_vec())
);
assert!(copied_page.try_get_key(b"/Parent").unwrap().is_null());
}
#[test]
fn copy_foreign_object_dirty_marks_a_nested_page_null_reservation() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let page = source.get_object_handle(ObjectRef::new(3, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(vec![(
b"/Kids".to_vec(),
ObjectHandle::array(vec![page.clone()]),
)]))
.expect("root");
let copied_root = target
.copy_foreign_object(&root)
.expect("copy root with nested page boundary");
let kids = copied_root.try_get_key(b"/Kids").unwrap();
let boundary_ref = kids
.as_array()
.expect("Kids is an array")
.first()
.expect("Kids has one element")
.object_ref()
.expect("nested page reservation is indirect");
let catalog_ref = target.root_ref().expect("target has a root");
let catalog = target.get_object_handle(catalog_ref);
catalog
.replace_key(b"/CopiedRoot", copied_root.clone())
.expect("copy_foreign_object mints a target-owned handle, same document as catalog");
let mut writer = PdfWriter::new(&mut target);
writer.set_object_stream_mode(ObjectStreamMode::Disable);
writer.set_output_memory().expect("configure memory output");
writer.write().expect("full rewrite");
let written_ref = writer
.get_renumbered_obj_gen(boundary_ref)
.expect("query renumbering")
.expect(
"nested page placeholder must survive a full rewrite instead of \
leaving the copied ancestor's array reference dangling",
);
let out = writer.get_buffer().expect("take full-rewrite output");
let mut reopened = Pdf::open(Cursor::new(out)).expect("reopen written output");
assert!(reopened.canonical_object_refs().contains(&written_ref));
let written_handle = reopened.get_object_handle(written_ref);
written_handle
.try_is_scalar()
.expect("resolve written placeholder");
assert!(written_handle.is_null());
}
#[test]
fn copy_foreign_object_shares_stream_buffers_without_copying_the_graph() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let data = Rc::new(b"foreign stream bytes".to_vec());
let stream = source
.new_stream_with_data(Rc::clone(&data))
.expect("source stream");
stream
.as_stream_dict()
.expect("source stream dictionary")
.replace_key(b"/Filter", ObjectHandle::name(b"FlateDecode".to_vec()))
.unwrap();
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", stream.clone()).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy stream graph");
let copied_stream = copied.try_get_key(b"/Stream").unwrap();
assert!(copied_stream.is_indirect());
assert!(Rc::ptr_eq(
&copied_stream.as_stream_data().expect("copied buffer"),
&data
));
assert_eq!(
copied_stream
.as_stream_dict()
.expect("copied stream dictionary")
.try_get_key(b"/Filter")
.unwrap()
.as_name(),
Some(b"FlateDecode".to_vec())
);
}
#[test]
fn copy_foreign_object_defers_provider_streams_and_supports_immediate_copy() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let calls = Rc::new(std::cell::RefCell::new(0usize));
let calls_for_provider = Rc::clone(&calls);
let stream = source.new_stream().expect("source stream");
stream
.replace_stream_data_with_retry_callback(
move |pipeline, _suppress_warnings, _will_retry| {
*calls_for_provider.borrow_mut() += 1;
pipeline
.write(b"deferred foreign bytes")
.map_err(Error::from)?;
pipeline.finish().map_err(Error::from)?;
Ok(true)
},
None,
None,
)
.expect("source provider");
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", stream.clone()).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy provider graph");
let copied_stream = copied.try_get_key(b"/Stream").unwrap();
assert!(copied_stream.as_stream_data().is_none());
assert_eq!(*calls.borrow(), 0);
assert_eq!(
copied_stream
.get_raw_stream_data()
.expect("deferred stream bytes")
.as_ref(),
b"deferred foreign bytes"
);
assert_eq!(*calls.borrow(), 1);
let mut immediate_source = minimal_pdf();
let mut immediate_target = minimal_pdf();
let immediate_stream = immediate_source.new_stream().expect("immediate stream");
immediate_stream
.replace_stream_data_with_callback(|_pipeline| Ok(()), None, None)
.expect("immediate provider");
immediate_source.set_immediate_copy_from(true);
let immediate_root = immediate_source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("immediate root");
immediate_root
.replace_key(b"/Stream", immediate_stream.clone())
.unwrap();
let immediate_copy = immediate_target
.copy_foreign_object(&immediate_root)
.expect("immediate foreign copy");
assert!(Rc::ptr_eq(
&immediate_stream
.as_stream_data()
.expect("materialized immediate source"),
&immediate_copy
.try_get_key(b"/Stream")
.unwrap()
.as_stream_data()
.expect("shared immediate buffer")
));
}
#[test]
fn copy_foreign_object_preserves_provider_failures_until_destination_read() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let stream = source.new_stream().expect("source stream");
stream
.replace_stream_data_with_retry_callback(
|_pipeline, _suppress, _retry| {
Err(Error::System("foreign provider failed".to_owned()))
},
None,
None,
)
.expect("source provider");
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", stream).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("provider failure must stay deferred");
let error = copied
.try_get_key(b"/Stream")
.unwrap()
.get_raw_stream_data()
.expect_err("destination read must propagate the foreign provider error");
assert!(matches!(error, Error::System(message) if message == "foreign provider failed"));
}
#[test]
fn copy_foreign_object_keeps_original_file_streams_lazy() {
let mut source = pdf_with_stream(b"original foreign bytes");
let mut target = minimal_pdf();
let source_stream = source.get_object_handle(ObjectRef::new(4, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", source_stream.clone()).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy original stream graph");
let copied_stream = copied.try_get_key(b"/Stream").unwrap();
assert!(copied_stream.as_stream_data().is_none());
assert_eq!(
copied_stream
.get_raw_stream_data()
.expect("original stream bytes")
.as_ref(),
b"original foreign bytes"
);
}
#[test]
fn copy_foreign_object_original_file_streams_are_not_bound_to_the_source_pdf() {
let mut target = minimal_pdf();
let copied_stream = {
let mut source = pdf_with_stream(b"source lifetime bytes");
let source_stream = source.get_object_handle(ObjectRef::new(4, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", source_stream).unwrap();
target
.copy_foreign_object(&root)
.expect("copy original stream graph")
.try_get_key(b"/Stream")
.unwrap()
};
assert_eq!(
copied_stream
.get_raw_stream_data()
.expect("original source stream remains readable after source Pdf drop")
.as_ref(),
b"source lifetime bytes"
);
}
#[test]
fn copy_foreign_original_stream_reports_late_source_failures_to_destination() {
let mut source = pdf_with_stream(b"source bytes that will be truncated");
let mut target = minimal_pdf();
let source_stream = source.get_object_handle(ObjectRef::new(4, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Stream", source_stream.clone())
.expect("attach source stream to root");
let copied_stream = target
.copy_foreign_object(&root)
.expect("copy original stream graph")
.try_get_key(b"/Stream")
.unwrap();
let expected_offset = u64::try_from(source_stream.get_parsed_offset())
.expect("source stream must retain its data offset");
source
.resolver
.with_reader_mut(|reader| reader.get_mut().clear());
let _ = copied_stream
.get_raw_stream_data()
.expect_err("truncated source must fail during deferred read");
let target_messages: Vec<_> = target
.repair_diagnostics()
.entries()
.iter()
.map(|diagnostic| diagnostic.message_string())
.collect();
assert!(
target_messages
.iter()
.any(|message| message.contains("unexpected EOF reading stream data")),
"destination must own deferred source warnings: {target_messages:?}"
);
assert!(target
.repair_diagnostics()
.entries()
.iter()
.any(|diagnostic| {
diagnostic.get_file_position() == expected_offset as i64
&& diagnostic
.message_string()
.contains("unexpected EOF reading stream data")
}));
assert!(source.repair_diagnostics().entries().is_empty());
}
#[test]
fn copy_foreign_object_rebuilds_direct_containers_with_destination_children() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let shared = source
.make_indirect_object_handle(ObjectHandle::integer(11))
.expect("shared child");
let nested = ObjectHandle::dictionary(vec![
(b"/Name".to_vec(), ObjectHandle::name(b"Nested".to_vec())),
(b"/Shared".to_vec(), shared.clone()),
]);
let array = ObjectHandle::array(vec![nested.clone(), shared.clone()]);
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Array", array).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy direct containers");
let copied_array = copied.try_get_key(b"/Array").unwrap();
let copied_items = copied_array.as_array().expect("copied array");
let copied_nested = copied_items[0].clone();
let copied_shared_from_dict = copied_nested.try_get_key(b"/Shared").unwrap();
let copied_shared_from_array = copied_items[1].clone();
assert!(copied_shared_from_dict.is_same_object_as(&copied_shared_from_array));
assert_eq!(
copied_nested.try_get_key(b"/Name").unwrap().as_name(),
Some(b"Nested".to_vec())
);
assert_ne!(copied_shared_from_array.object_ref(), shared.object_ref());
}
#[test]
fn copy_foreign_value_reuses_the_persistent_map_for_direct_containers() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let shared = source
.make_indirect_object_handle(ObjectHandle::integer(11))
.expect("shared child");
let value = ObjectHandle::dictionary(vec![(b"/Shared".to_vec(), shared.clone())]);
let copied = copy_foreign_value(&mut target, source.unique_id(), &value)
.expect("copy direct foreign value");
let copied_again = copy_foreign_value(&mut target, source.unique_id(), &value)
.expect("reuse direct foreign value map");
assert!(copied
.try_get_key(b"/Shared")
.unwrap()
.is_same_object_as(&copied_again.try_get_key(b"/Shared").unwrap()));
assert_eq!(
copied.try_get_key(b"/Shared").unwrap().as_integer(),
Some(11)
);
assert!(!copied
.try_get_key(b"/Shared")
.unwrap()
.is_same_object_as(&shared));
}
#[test]
fn copy_foreign_value_rejects_wrong_document_identity() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let foreign = source.get_object_handle(ObjectRef::new(3, 0));
let target_id = target.unique_id();
let same_document = copy_foreign_value(&mut target, target_id, &foreign)
.expect_err("a target-owned source id must be rejected");
assert!(matches!(same_document, Error::System(message)
if message == "QPDF::copyForeign called with object from this QPDF"));
let wrong_source_id = target_id.wrapping_add(1);
let wrong_owner = copy_foreign_value(&mut target, wrong_source_id, &foreign)
.expect_err("a foreign handle owned by another source id must be rejected");
assert!(matches!(wrong_owner, Error::System(message)
if message == "QPDF::copyForeign encountered an object owned by a different document"));
}
#[test]
fn copy_foreign_object_omits_a_dictionary_key_left_unreserved_by_a_pages_boundary() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let pages = source.get_object_handle(ObjectRef::new(2, 0));
let root = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("root");
root.replace_key(b"/Kids", pages).unwrap();
let copied = target
.copy_foreign_object(&root)
.expect("copy root referencing an unreserved /Pages object");
assert!(
!copied.try_has_key(b"/Kids").unwrap(),
"a direct-null replacement must remove the key, matching qpdf's replaceKey"
);
}
#[test]
fn copy_foreign_object_copies_top_level_scalar_as_a_destination_handle() {
let mut source = minimal_pdf();
let mut target = minimal_pdf();
let scalar = source
.make_indirect_object_handle(ObjectHandle::integer(123))
.expect("scalar");
let copied = target.copy_foreign_object(&scalar).expect("copy scalar");
assert!(copied.is_indirect());
assert_eq!(copied.as_integer(), Some(123));
assert!(!copied.is_same_object_as(&scalar));
}
#[test]
fn copy_foreign_object_survives_a_long_indirect_reference_chain_on_a_small_stack() {
const CHAIN_DEPTH: usize = 2_000;
let outcome = std::thread::Builder::new()
.stack_size(256 * 1024)
.spawn(move || {
let mut source = minimal_pdf();
let mut leaf = source
.make_indirect_object_handle(ObjectHandle::integer(0))
.expect("leaf");
for _ in 0..CHAIN_DEPTH {
let node = source
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("chain node");
node.replace_key(b"/Next", leaf.clone()).unwrap();
leaf = node;
}
let mut target = minimal_pdf();
let copied = target
.copy_foreign_object(&leaf)
.expect("a long acyclic chain must not overflow the caller stack");
let is_indirect = copied.is_indirect();
std::mem::forget(source);
std::mem::forget(target);
std::mem::forget(leaf);
std::mem::forget(copied);
is_indirect
})
.expect("spawn small-stack copier thread")
.join()
.expect("copy_foreign_object must not overflow the caller stack");
assert!(outcome);
}
}