use std::collections::BTreeSet;
use std::io::{Read, Seek};
use crate::default_appearance::{parse_default_appearance, TextColor};
use crate::json_inspect::decode_pdf_text_string;
use crate::object::write_literal_string;
use crate::page_object_helper::PageBox;
use crate::pages::DEFAULT_MAX_PAGE_TREE_DEPTH;
use crate::ref_chain::resolve_ref_chain;
use crate::standard_font_metrics::StandardFont;
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result, Stream};
pub(crate) fn color_ops(color: &TextColor, out: &mut Vec<u8>) {
match color {
TextColor::Gray(g) => {
out.extend_from_slice(fmt_f64(*g).as_bytes());
out.extend_from_slice(b" g\n");
}
TextColor::Rgb(r, g, b) => {
out.extend_from_slice(fmt_f64(*r).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(*g).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(*b).as_bytes());
out.extend_from_slice(b" rg\n");
}
TextColor::Cmyk(c, m, y, k) => {
out.extend_from_slice(fmt_f64(*c).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(*m).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(*y).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(*k).as_bytes());
out.extend_from_slice(b" k\n");
}
}
}
pub(crate) fn install_normal_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
content: Vec<u8>,
bbox_w: f64,
bbox_h: f64,
font_resource: Option<(Vec<u8>, Vec<u8>, ObjectRef)>,
) -> Result<ObjectRef> {
let font_resource_ref = if let Some((ref res_key, ref base_name, font_obj_ref)) = font_resource
{
let mut inner_font_dict = Dictionary::new();
inner_font_dict.insert("Type", Object::Name(b"Font".to_vec()));
inner_font_dict.insert("Subtype", Object::Name(b"Type1".to_vec()));
inner_font_dict.insert("BaseFont", Object::Name(base_name.clone()));
inner_font_dict.insert("Encoding", Object::Name(b"WinAnsiEncoding".to_vec()));
pdf.set_object(font_obj_ref, Object::Dictionary(inner_font_dict));
let mut font_dict = Dictionary::new();
font_dict.insert(
String::from_utf8_lossy(res_key).into_owned(),
Object::Reference(font_obj_ref),
);
Some(font_dict)
} else {
None
};
let xobj_ref = next_object_ref(pdf)?;
let mut sdict = Dictionary::new();
sdict.insert("Type", Object::Name(b"XObject".to_vec()));
sdict.insert("Subtype", Object::Name(b"Form".to_vec()));
sdict.insert("FormType", Object::Integer(1));
sdict.insert(
"BBox",
Object::Array(vec![
Object::Real(0.0),
Object::Real(0.0),
Object::Real(bbox_w),
Object::Real(bbox_h),
]),
);
if let Some(fdict) = font_resource_ref {
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(fdict));
sdict.insert("Resources", Object::Dictionary(resources));
}
pdf.set_object(xobj_ref, Object::Stream(Stream::new(sdict, content)));
let widget_obj = pdf.resolve(widget_ref)?;
let mut widget_dict = match widget_obj {
Object::Dictionary(d) => d,
_ => {
return Err(Error::Unsupported(format!(
"widget object {widget_ref} is not a dictionary"
)))
}
};
let mut ap_dict = match widget_dict.get("AP") {
Some(Object::Dictionary(d)) => d.clone(),
Some(value @ Object::Reference(_)) => resolve_ref_chain(pdf, value)?
.0
.into_dict()
.unwrap_or_default(),
_ => Dictionary::new(),
};
ap_dict.insert("N", Object::Reference(xobj_ref));
widget_dict.insert("AP", Object::Dictionary(ap_dict));
pdf.set_object(widget_ref, Object::Dictionary(widget_dict));
Ok(xobj_ref)
}
pub(crate) struct TextAppearanceParams {
pub text_bytes: Vec<u8>,
pub font_resource_name: Vec<u8>,
pub font_size: f64,
pub color: TextColor,
pub bbox_w: f64,
pub bbox_h: f64,
pub quadding: i64,
pub multiline: bool,
pub std_font: Option<StandardFont>,
}
pub(crate) fn build_text_appearance_content(p: &TextAppearanceParams) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(b"/Tx BMC\n");
out.extend_from_slice(b"BT\n");
out.push(b'/');
crate::object::write_name_escaped(&mut out, &p.font_resource_name);
out.push(b' ');
out.extend_from_slice(fmt_f64(p.font_size).as_bytes());
out.extend_from_slice(b" Tf\n");
color_ops(&p.color, &mut out);
if p.multiline {
render_multiline(p, &mut out);
} else {
render_singleline(p, &mut out);
}
out.extend_from_slice(b"ET\n");
out.extend_from_slice(b"EMC\n");
out
}
pub fn generate_text_field_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let ft = resolve_inherited_name(pdf, widget_ref, b"FT")?;
if ft.as_deref() != Some(b"Tx") {
return Ok(None);
}
let raw_value = resolve_inherited_object(pdf, widget_ref, b"V")?;
let value_bytes: Option<Vec<u8>> = match raw_value {
None => None,
Some(Object::String(bytes)) => decode_pdf_text_string(&bytes)
.map(|s| to_winansi_bytes(&s))
.or(Some(bytes)),
Some(Object::Reference(r)) => {
let obj = pdf.resolve(r)?;
match obj {
Object::String(bytes) => decode_pdf_text_string(&bytes)
.map(|s| to_winansi_bytes(&s))
.or(Some(bytes)),
_ => None,
}
}
_ => None,
};
let text_bytes = match value_bytes {
Some(b) => b,
None => return Ok(None),
};
let rect = resolve_rect(pdf, widget_ref)?;
let (bbox_w, bbox_h) = match rect {
Some(r) => {
let w = (r.urx - r.llx).abs();
let h = (r.ury - r.lly).abs();
if !w.is_finite() || !h.is_finite() || w < 1.0 || h < 1.0 {
return Ok(None);
}
(w, h)
}
None => return Ok(None),
};
let da_bytes = resolve_da(pdf, widget_ref)?;
let da = parse_default_appearance(da_bytes.as_deref().unwrap_or(b""));
let quadding = resolve_inherited_integer(pdf, widget_ref, b"Q")?.unwrap_or(0);
let ff =
u32::try_from(resolve_inherited_integer(pdf, widget_ref, b"Ff")?.unwrap_or(0)).unwrap_or(0);
let multiline = (ff >> 12) & 1 != 0;
let font_name_bytes: Vec<u8> = da.font_name.clone().unwrap_or_else(|| b"Helv".to_vec());
let std_font = match StandardFont::from_base_name(&font_name_bytes) {
Some(sf) => sf,
None => lookup_dr_basefont(pdf, widget_ref, &font_name_bytes)?
.unwrap_or(StandardFont::Helvetica),
};
let base_font_name = official_base_name(std_font).to_vec();
let font_obj_ref = next_object_ref(pdf)?;
let font_size = if da.auto_size {
let candidate = (bbox_h - 2.0).clamp(4.0, 12.0);
candidate
} else {
da.font_size
};
let font_resource_name: Vec<u8> = font_name_bytes.clone();
let params = TextAppearanceParams {
text_bytes,
font_resource_name: font_resource_name.clone(),
font_size,
color: da.color,
bbox_w,
bbox_h,
quadding,
multiline,
std_font: Some(std_font),
};
let content = build_text_appearance_content(¶ms);
let xobj_ref = install_normal_appearance(
pdf,
widget_ref,
content,
bbox_w,
bbox_h,
Some((font_resource_name, base_font_name, font_obj_ref)),
)?;
Ok(Some(xobj_ref))
}
pub fn generate_button_field_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let ft = resolve_inherited_name(pdf, widget_ref, b"FT")?;
if ft.as_deref() != Some(b"Btn") {
return Ok(None);
}
let ff =
u32::try_from(resolve_inherited_integer(pdf, widget_ref, b"Ff")?.unwrap_or(0)).unwrap_or(0);
let is_pushbutton = ff & 0x10000 != 0; let is_radio = !is_pushbutton && ff & 0x8000 != 0;
let rect = resolve_rect(pdf, widget_ref)?;
let (bbox_w, bbox_h) = match rect {
Some(r) => {
let w = (r.urx - r.llx).abs();
let h = (r.ury - r.lly).abs();
if !w.is_finite() || !h.is_finite() || w < 1.0 || h < 1.0 {
return Ok(None);
}
(w, h)
}
None => return Ok(None),
};
let mk_dict: Option<Dictionary> = {
let widget_obj = pdf.resolve_borrowed(widget_ref)?;
let mk_val = widget_obj.as_dict().and_then(|d| d.get("MK").cloned());
let _ = widget_obj;
resolve_to_dict(pdf, mk_val)?
};
if is_pushbutton {
generate_pushbutton_appearance(pdf, widget_ref, bbox_w, bbox_h, mk_dict.as_ref())
} else {
generate_checkbox_radio_appearance(
pdf,
widget_ref,
bbox_w,
bbox_h,
mk_dict.as_ref(),
is_radio,
)
}
}
fn generate_pushbutton_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
bbox_w: f64,
bbox_h: f64,
mk_dict: Option<&Dictionary>,
) -> Result<Option<ObjectRef>> {
let caption_obj = match mk_dict.and_then(|d| d.get("CA").cloned()) {
Some(Object::Reference(r)) => Some(pdf.resolve(r)?),
other => other,
};
let caption_bytes: Vec<u8> = match caption_obj {
Some(Object::String(s)) => decode_pdf_text_string(&s)
.map(|us| to_winansi_bytes(&us))
.unwrap_or(s),
_ => Vec::new(),
};
let font_size = (bbox_h - 4.0).clamp(4.0, 12.0);
let params = TextAppearanceParams {
text_bytes: caption_bytes,
font_resource_name: b"Helv".to_vec(),
font_size,
color: TextColor::Gray(0.0),
bbox_w,
bbox_h,
quadding: 1, multiline: false,
std_font: Some(StandardFont::Helvetica),
};
let content = build_text_appearance_content(¶ms);
let font_obj_ref = next_object_ref(pdf)?;
let xobj_ref = install_normal_appearance(
pdf,
widget_ref,
content,
bbox_w,
bbox_h,
Some((b"Helv".to_vec(), b"Helvetica".to_vec(), font_obj_ref)),
)?;
Ok(Some(xobj_ref))
}
fn generate_checkbox_radio_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
bbox_w: f64,
bbox_h: f64,
mk_dict: Option<&Dictionary>,
is_radio: bool,
) -> Result<Option<ObjectRef>> {
let on_state_name: Vec<u8> = {
let widget_obj = pdf.resolve_borrowed(widget_ref)?;
let wdict = widget_obj.as_dict();
let ap_val = wdict.and_then(|d| d.get("AP").cloned());
let as_val = wdict.and_then(|d| d.get("AS").cloned());
let _ = widget_obj;
let ap_dict = resolve_to_dict(pdf, ap_val)?;
let n_dict = if let Some(ap) = ap_dict {
let n_val = ap.get("N").cloned();
resolve_to_dict(pdf, n_val)?
} else {
None
};
let from_ap = n_dict.and_then(|d| {
d.iter()
.find(|(k, _)| *k != b"Off")
.map(|(k, _)| k.to_vec())
});
if let Some(name) = from_ap {
name
} else {
let as_resolved = match as_val {
Some(Object::Reference(r)) => Some(pdf.resolve(r)?),
other => other,
};
match as_resolved {
Some(Object::Name(n)) if n != b"Off" => n,
_ => b"Yes".to_vec(),
}
}
};
let default_glyph: &[u8] = if is_radio { b"l" } else { b"4" };
let ca_obj = match mk_dict.and_then(|d| d.get("CA").cloned()) {
Some(Object::Reference(r)) => Some(pdf.resolve(r)?),
other => other,
};
let ca_bytes: Vec<u8> = match ca_obj {
Some(Object::String(s)) => {
if s.starts_with(&[0xFE, 0xFF]) {
match decode_pdf_text_string(&s) {
Some(text) if !text.is_empty() && text.chars().all(|c| (c as u32) <= 0xFF) => {
text.chars().map(|c| c as u8).collect()
}
_ => default_glyph.to_vec(),
}
} else if s.is_empty() {
default_glyph.to_vec()
} else {
s
}
}
_ => default_glyph.to_vec(),
};
let size = (bbox_w.min(bbox_h) * 0.8).clamp(4.0, 72.0);
let tx = ((bbox_w - size * 0.7) / 2.0).max(0.0);
let ty = ((bbox_h - size) / 2.0 + size * 0.15).max(0.0);
let mut on_content = Vec::new();
on_content.extend_from_slice(b"q\nBT\n/ZaDb ");
on_content.extend_from_slice(fmt_f64(size).as_bytes());
on_content.extend_from_slice(b" Tf\n0 g\n");
on_content.extend_from_slice(fmt_f64(tx).as_bytes());
on_content.push(b' ');
on_content.extend_from_slice(fmt_f64(ty).as_bytes());
on_content.extend_from_slice(b" Td\n");
write_literal_string(&mut on_content, &ca_bytes);
on_content.extend_from_slice(b" Tj\nET\nQ\n");
let off_content: Vec<u8> = b"q Q\n".to_vec();
install_state_appearances(
pdf,
widget_ref,
&on_state_name,
on_content,
off_content,
bbox_w,
bbox_h,
)
}
fn install_state_appearances<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
on_state_name: &[u8],
on_content: Vec<u8>,
off_content: Vec<u8>,
bbox_w: f64,
bbox_h: f64,
) -> Result<Option<ObjectRef>> {
let font_ref = next_object_ref(pdf)?;
{
let mut fd = Dictionary::new();
fd.insert("Type", Object::Name(b"Font".to_vec()));
fd.insert("Subtype", Object::Name(b"Type1".to_vec()));
fd.insert("BaseFont", Object::Name(b"ZapfDingbats".to_vec()));
pdf.set_object(font_ref, Object::Dictionary(fd));
}
let make_resources = || -> Dictionary {
let mut font_dict = Dictionary::new();
font_dict.insert("ZaDb", Object::Reference(font_ref));
let mut res = Dictionary::new();
res.insert("Font", Object::Dictionary(font_dict));
res
};
let on_ref = next_object_ref(pdf)?;
{
let mut sdict = Dictionary::new();
sdict.insert("Type", Object::Name(b"XObject".to_vec()));
sdict.insert("Subtype", Object::Name(b"Form".to_vec()));
sdict.insert("FormType", Object::Integer(1));
sdict.insert(
"BBox",
Object::Array(vec![
Object::Real(0.0),
Object::Real(0.0),
Object::Real(bbox_w),
Object::Real(bbox_h),
]),
);
sdict.insert("Resources", Object::Dictionary(make_resources()));
pdf.set_object(on_ref, Object::Stream(Stream::new(sdict, on_content)));
}
let off_ref = next_object_ref(pdf)?;
{
let mut sdict = Dictionary::new();
sdict.insert("Type", Object::Name(b"XObject".to_vec()));
sdict.insert("Subtype", Object::Name(b"Form".to_vec()));
sdict.insert("FormType", Object::Integer(1));
sdict.insert(
"BBox",
Object::Array(vec![
Object::Real(0.0),
Object::Real(0.0),
Object::Real(bbox_w),
Object::Real(bbox_h),
]),
);
sdict.insert("Resources", Object::Dictionary(make_resources()));
pdf.set_object(off_ref, Object::Stream(Stream::new(sdict, off_content)));
}
let build_state_dict = |on: ObjectRef, off: ObjectRef| -> Dictionary {
let mut d = Dictionary::new();
d.insert(on_state_name, Object::Reference(on));
d.insert("Off", Object::Reference(off));
d
};
let mut ap = Dictionary::new();
ap.insert("N", Object::Dictionary(build_state_dict(on_ref, off_ref)));
ap.insert("D", Object::Dictionary(build_state_dict(on_ref, off_ref)));
let widget_obj = pdf.resolve(widget_ref)?;
let mut wdict = match widget_obj {
Object::Dictionary(d) => d,
_ => {
return Err(Error::Unsupported(format!(
"widget object {widget_ref} is not a dictionary"
)))
}
};
wdict.insert("AP", Object::Dictionary(ap));
if wdict.get("AS").is_none() {
wdict.insert("AS", Object::Name(b"Off".to_vec()));
}
pdf.set_object(widget_ref, Object::Dictionary(wdict));
Ok(Some(on_ref))
}
fn official_base_name(font: StandardFont) -> &'static [u8] {
match font {
StandardFont::Helvetica => b"Helvetica",
StandardFont::HelveticaBold => b"Helvetica-Bold",
StandardFont::HelveticaOblique => b"Helvetica-Oblique",
StandardFont::HelveticaBoldOblique => b"Helvetica-BoldOblique",
StandardFont::TimesRoman => b"Times-Roman",
StandardFont::TimesBold => b"Times-Bold",
StandardFont::TimesItalic => b"Times-Italic",
StandardFont::TimesBoldItalic => b"Times-BoldItalic",
StandardFont::Courier => b"Courier",
StandardFont::CourierBold => b"Courier-Bold",
StandardFont::CourierOblique => b"Courier-Oblique",
StandardFont::CourierBoldOblique => b"Courier-BoldOblique",
StandardFont::Symbol => b"Symbol",
StandardFont::ZapfDingbats => b"ZapfDingbats",
}
}
fn fmt_f64(v: f64) -> String {
if !v.is_finite() {
return "0".to_string();
}
let s = format!("{:.4}", v);
let s = s.trim_end_matches('0');
let s = s.trim_end_matches('.');
if s.is_empty() || s == "-" {
return "0".to_string();
}
s.to_string()
}
fn to_winansi_bytes(s: &str) -> Vec<u8> {
let mut out = Vec::with_capacity(s.len());
for ch in s.chars() {
let code = ch as u32;
if code <= 0x007F || (0x00A0..=0x00FF).contains(&code) {
out.push(code as u8);
} else {
let byte = match ch {
'\u{20AC}' => 0x80, '\u{201A}' => 0x82, '\u{0192}' => 0x83, '\u{201E}' => 0x84, '\u{2026}' => 0x85, '\u{2020}' => 0x86, '\u{2021}' => 0x87, '\u{02C6}' => 0x88, '\u{2030}' => 0x89, '\u{0160}' => 0x8A, '\u{2039}' => 0x8B, '\u{0152}' => 0x8C, '\u{017D}' => 0x8E, '\u{2018}' => 0x91, '\u{2019}' => 0x92, '\u{201C}' => 0x93, '\u{201D}' => 0x94, '\u{2022}' => 0x95, '\u{2013}' => 0x96, '\u{2014}' => 0x97, '\u{02DC}' => 0x98, '\u{2122}' => 0x99, '\u{0161}' => 0x9A, '\u{203A}' => 0x9B, '\u{0153}' => 0x9C, '\u{017E}' => 0x9E, '\u{0178}' => 0x9F, _ => b'?',
};
out.push(byte);
}
}
out
}
fn next_object_ref<R: Read + Seek>(pdf: &Pdf<R>) -> Result<ObjectRef> {
let n = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| Error::Unsupported("object-number space exhausted".to_string()))?;
Ok(ObjectRef::new(n, 0))
}
fn resolve_inherited_name<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: ObjectRef,
key: &[u8],
) -> Result<Option<Vec<u8>>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = start;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
return Err(Error::Unsupported(format!(
"field tree depth exceeds maximum of {} at {}",
DEFAULT_MAX_PAGE_TREE_DEPTH, current
)));
}
if !seen.insert(current) {
return Ok(None);
}
let node_obj = pdf.resolve_borrowed(current)?;
let Some(dict) = node_obj.as_dict() else {
return Err(Error::Unsupported(format!(
"field tree node {current} is not a dictionary"
)));
};
let val = dict.get(key).cloned();
let parent_val = dict.get("Parent").cloned();
let _ = node_obj;
if let Some(val) = val {
let resolved = match val {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
match resolved {
Object::Null => {}
Object::Name(bytes) => return Ok(Some(bytes)),
_ => {}
}
}
match parent_val {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
fn resolve_inherited_object<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: ObjectRef,
key: &[u8],
) -> Result<Option<Object>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = start;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
return Err(Error::Unsupported(format!(
"field tree depth exceeds maximum of {} at {}",
DEFAULT_MAX_PAGE_TREE_DEPTH, current
)));
}
if !seen.insert(current) {
return Ok(None);
}
let node_obj = pdf.resolve_borrowed(current)?;
let Some(dict) = node_obj.as_dict() else {
return Err(Error::Unsupported(format!(
"field tree node {current} is not a dictionary"
)));
};
if let Some(val) = dict.get(key).cloned() {
match val {
Object::Null => {}
other => return Ok(Some(other)),
}
}
match dict.get("Parent").cloned() {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
fn resolve_inherited_integer<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: ObjectRef,
key: &[u8],
) -> Result<Option<i64>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = start;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
return Err(Error::Unsupported(format!(
"field tree depth exceeds maximum of {} at {}",
DEFAULT_MAX_PAGE_TREE_DEPTH, current
)));
}
if !seen.insert(current) {
return Ok(None);
}
let node_obj = pdf.resolve_borrowed(current)?;
let Some(dict) = node_obj.as_dict() else {
return Err(Error::Unsupported(format!(
"field tree node {current} is not a dictionary"
)));
};
let val = dict.get(key).cloned();
let parent_val = dict.get("Parent").cloned();
let _ = node_obj;
if let Some(val) = val {
let resolved = match val {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
match resolved {
Object::Null => {}
Object::Integer(n) => return Ok(Some(n)),
_ => {}
}
}
match parent_val {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
fn resolve_da<R: Read + Seek>(pdf: &mut Pdf<R>, start: ObjectRef) -> Result<Option<Vec<u8>>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = start;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
pdf.push_warning(format!(
"/DA inheritance: parent chain exceeded max depth {DEFAULT_MAX_PAGE_TREE_DEPTH} at {current}; falling back to /AcroForm /DA"
));
break;
}
if !seen.insert(current) {
pdf.push_warning(format!(
"/DA inheritance: cycle detected at {current}; falling back to /AcroForm /DA"
));
break;
}
let node_obj = pdf.resolve_borrowed(current)?;
let extracted = node_obj
.as_dict()
.map(|dict| (dict.get("DA").cloned(), dict.get("Parent").cloned()));
let _ = node_obj;
let Some((da_val, parent_val)) = extracted else {
pdf.push_warning(format!(
"/DA inheritance: /Parent node {current} is not a dictionary; falling back to /AcroForm /DA"
));
break;
};
if let Some(val) = da_val {
let resolved_val = match val {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
match resolved_val {
Object::Null => {}
Object::String(bytes) => return Ok(Some(bytes)),
_ => {}
}
}
match parent_val {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => break,
}
}
let Some(root_ref) = pdf.root_ref() else {
return Ok(None);
};
let catalog_obj = pdf.resolve_borrowed(root_ref)?;
let Some(catalog) = catalog_obj.as_dict() else {
return Ok(None);
};
let acroform_val = catalog.get("AcroForm").cloned();
let acroform_dict: Option<Dictionary> = match acroform_val {
None | Some(Object::Null) => None,
Some(Object::Dictionary(d)) => Some(d),
Some(Object::Reference(r)) => resolve_ref_chain(pdf, &Object::Reference(r))?.0.into_dict(),
_ => None,
};
let da_raw = acroform_dict.as_ref().and_then(|d| d.get("DA")).cloned();
let da = match da_raw {
None | Some(Object::Null) => None,
Some(Object::String(bytes)) => Some(bytes),
Some(Object::Reference(r)) => {
let resolved = pdf.resolve(r)?;
match resolved {
Object::String(bytes) => Some(bytes),
_ => None,
}
}
_ => None,
};
Ok(da)
}
fn resolve_to_dict<R: Read + Seek>(
pdf: &mut Pdf<R>,
value: Option<Object>,
) -> Result<Option<Dictionary>> {
match value {
None | Some(Object::Null) => Ok(None),
Some(Object::Dictionary(d)) => Ok(Some(d)),
Some(Object::Reference(r)) => {
Ok(resolve_ref_chain(pdf, &Object::Reference(r))?.0.into_dict())
}
Some(_) => Ok(None),
}
}
fn lookup_dr_basefont<R: Read + Seek>(
pdf: &mut Pdf<R>,
start: ObjectRef,
resource_name: &[u8],
) -> Result<Option<StandardFont>> {
let mut dr_candidates: Vec<Dictionary> = Vec::new();
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = start;
let mut depth: usize = 0;
loop {
if depth >= DEFAULT_MAX_PAGE_TREE_DEPTH {
pdf.push_warning(format!(
"/DR font lookup: parent chain exceeded max depth {DEFAULT_MAX_PAGE_TREE_DEPTH} at {current}; falling back to /AcroForm /DR"
));
break;
}
if !seen.insert(current) {
pdf.push_warning(format!(
"/DR font lookup: cycle detected at {current}; falling back to /AcroForm /DR"
));
break;
}
let node = pdf.resolve_borrowed(current)?;
let extracted = node
.as_dict()
.map(|dict| (dict.get("DR").cloned(), dict.get("Parent").cloned()));
let _ = node;
let Some((dr_val, parent_val)) = extracted else {
pdf.push_warning(format!(
"/DR font lookup: /Parent node {current} is not a dictionary; falling back to /AcroForm /DR"
));
break;
};
if let Some(dr) = resolve_to_dict(pdf, dr_val)? {
dr_candidates.push(dr);
}
match parent_val {
Some(Object::Reference(r)) => {
current = r;
depth += 1;
}
_ => break,
}
}
if let Some(root_ref) = pdf.root_ref() {
let catalog = pdf.resolve_borrowed(root_ref)?;
let acroform_val = catalog.as_dict().and_then(|c| c.get("AcroForm").cloned());
let _ = catalog;
if let Some(acroform) = resolve_to_dict(pdf, acroform_val)? {
let dr_val = acroform.get("DR").cloned();
if let Some(dr) = resolve_to_dict(pdf, dr_val)? {
dr_candidates.push(dr);
}
}
}
for dr in dr_candidates {
let font_val = dr.get("Font").cloned();
let Some(font_dict) = resolve_to_dict(pdf, font_val)? else {
continue;
};
let res_val = font_dict.get(resource_name).cloned();
let Some(res) = resolve_to_dict(pdf, res_val)? else {
continue;
};
let base_font = match res.get("BaseFont").cloned() {
Some(Object::Name(n)) => Some(n),
Some(Object::Reference(r)) => pdf.resolve(r)?.into_name(),
_ => None,
};
if let Some(bf) = base_font {
if let Some(sf) = StandardFont::from_base_name(&bf) {
return Ok(Some(sf));
}
}
}
Ok(None)
}
fn resolve_rect<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<PageBox>> {
let obj = pdf.resolve_borrowed(widget_ref)?;
let Some(dict) = obj.as_dict() else {
return Ok(None);
};
let rect_val = match dict.get("Rect").cloned() {
None | Some(Object::Null) => return Ok(None),
Some(v) => v,
};
let arr = match rect_val {
Object::Array(a) => a,
Object::Reference(r) => {
let resolved = pdf.resolve(r)?;
match resolved {
Object::Array(a) => a,
_ => return Ok(None),
}
}
_ => return Ok(None),
};
if arr.len() != 4 {
return Ok(None);
}
let nums: Vec<f64> = arr
.iter()
.map(|o| match o {
Object::Real(f) | Object::RealLiteral { value: f, .. } => Some(*f),
Object::Integer(i) => Some(*i as f64),
_ => None,
})
.collect::<Option<Vec<_>>>()
.unwrap_or_default();
if nums.len() != 4 {
return Ok(None);
}
Ok(Some(PageBox::new(nums[0], nums[1], nums[2], nums[3])))
}
fn render_singleline(p: &TextAppearanceParams, out: &mut Vec<u8>) {
let x = compute_x_offset(p, &p.text_bytes);
let y = ((p.bbox_h - p.font_size) / 2.0 + p.font_size * 0.2).max(2.0);
out.extend_from_slice(fmt_f64(x).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(y).as_bytes());
out.extend_from_slice(b" Td\n");
write_literal_string(out, &p.text_bytes);
out.extend_from_slice(b" Tj\n");
}
fn render_multiline(p: &TextAppearanceParams, out: &mut Vec<u8>) {
let leading = p.font_size * 1.15;
let first_y = p.bbox_h - p.font_size - 2.0;
let effective_w = (p.bbox_w - 4.0).max(0.0);
let lines = word_wrap(&p.text_bytes, p.font_size, effective_w, p.std_font);
let mut prev_x = 0.0_f64;
for (i, line) in lines.iter().enumerate() {
let x = compute_x_offset(p, line);
if i == 0 {
out.extend_from_slice(fmt_f64(x).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(first_y).as_bytes());
out.extend_from_slice(b" Td\n");
} else {
let dx = x - prev_x;
out.extend_from_slice(fmt_f64(dx).as_bytes());
out.push(b' ');
out.extend_from_slice(fmt_f64(-leading).as_bytes());
out.extend_from_slice(b" Td\n");
}
prev_x = x;
write_literal_string(out, line);
out.extend_from_slice(b" Tj\n");
}
}
fn compute_x_offset(p: &TextAppearanceParams, text: &[u8]) -> f64 {
match p.quadding {
1 => {
let w = p
.std_font
.map_or(0.0, |sf| sf.string_width(text, p.font_size));
((p.bbox_w - w) / 2.0).max(2.0)
}
2 => {
let w = p
.std_font
.map_or(0.0, |sf| sf.string_width(text, p.font_size));
(p.bbox_w - w - 2.0).max(2.0)
}
_ => 2.0, }
}
fn word_wrap(
text: &[u8],
font_size: f64,
max_width: f64,
std_font: Option<StandardFont>,
) -> Vec<Vec<u8>> {
let Some(sf) = std_font else {
return vec![text.to_vec()];
};
if max_width <= 0.0 {
return vec![text.to_vec()];
}
let mut lines: Vec<Vec<u8>> = Vec::new();
for segment in split_hard_lines(text) {
let mut current: Vec<u8> = Vec::new();
let mut first = true;
for word in segment.split(|&b| b == b' ') {
if first {
current.extend_from_slice(word);
first = false;
} else {
let mut candidate = current.clone();
candidate.push(b' ');
candidate.extend_from_slice(word);
if sf.string_width(&candidate, font_size) <= max_width {
current = candidate;
} else {
lines.push(current.clone());
current.clear();
current.extend_from_slice(word);
}
}
}
lines.push(current);
}
if lines.is_empty() {
lines.push(Vec::new());
}
lines
}
fn split_hard_lines(text: &[u8]) -> Vec<Vec<u8>> {
let mut out: Vec<Vec<u8>> = Vec::new();
let mut line: Vec<u8> = Vec::new();
let mut i = 0;
while i < text.len() {
match text[i] {
b'\r' => {
out.push(std::mem::take(&mut line));
if text.get(i + 1) == Some(&b'\n') {
i += 1;
}
}
b'\n' => out.push(std::mem::take(&mut line)),
b => line.push(b),
}
i += 1;
}
out.push(line);
out
}
pub fn generate_choice_field_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let ft = resolve_inherited_name(pdf, widget_ref, b"FT")?;
if ft.as_deref() != Some(b"Ch") {
return Ok(None);
}
let ff = resolve_inherited_integer(pdf, widget_ref, b"Ff")?.unwrap_or(0);
let is_combo = ff & 0x20000 != 0;
let rect = resolve_rect(pdf, widget_ref)?;
let (bbox_w, bbox_h) = match rect {
Some(r) => {
let w = (r.urx - r.llx).abs();
let h = (r.ury - r.lly).abs();
if !w.is_finite() || !h.is_finite() || w < 1.0 || h < 1.0 {
return Ok(None);
}
(w, h)
}
None => return Ok(None),
};
let da_bytes = resolve_da(pdf, widget_ref)?;
let da = parse_default_appearance(da_bytes.as_deref().unwrap_or(b""));
let font_name_bytes: Vec<u8> = da.font_name.clone().unwrap_or_else(|| b"Helv".to_vec());
let std_font = match StandardFont::from_base_name(&font_name_bytes) {
Some(sf) => sf,
None => lookup_dr_basefont(pdf, widget_ref, &font_name_bytes)?
.unwrap_or(StandardFont::Helvetica),
};
let base_font_name = official_base_name(std_font).to_vec();
let font_resource_name = font_name_bytes.clone();
let font_info = ChFontInfo {
resource_name: font_resource_name,
base_name: base_font_name,
std_font,
};
let quadding = resolve_inherited_integer(pdf, widget_ref, b"Q")?.unwrap_or(0);
if is_combo {
generate_combo_appearance(pdf, widget_ref, bbox_w, bbox_h, &da, font_info, quadding)
} else {
generate_list_appearance(pdf, widget_ref, bbox_w, bbox_h, &da, font_info)
}
}
struct ChFontInfo {
resource_name: Vec<u8>,
base_name: Vec<u8>,
std_font: StandardFont,
}
fn generate_combo_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
bbox_w: f64,
bbox_h: f64,
da: &crate::default_appearance::DefaultAppearance,
font: ChFontInfo,
quadding: i64,
) -> Result<Option<ObjectRef>> {
let raw_value = resolve_inherited_object(pdf, widget_ref, b"V")?;
let text_bytes: Vec<u8> = match raw_value {
None => Vec::new(),
Some(Object::String(bytes)) => decode_pdf_text_string(&bytes)
.map(|s| to_winansi_bytes(&s))
.unwrap_or(bytes),
Some(Object::Reference(r)) => {
let obj = pdf.resolve(r)?;
match obj {
Object::String(bytes) => decode_pdf_text_string(&bytes)
.map(|s| to_winansi_bytes(&s))
.unwrap_or(bytes),
_ => Vec::new(),
}
}
_ => Vec::new(),
};
let text_bytes = resolve_combo_display(pdf, widget_ref, text_bytes);
let font_size = if da.auto_size {
(bbox_h - 2.0).clamp(4.0, 12.0)
} else {
da.font_size
};
let params = TextAppearanceParams {
text_bytes,
font_resource_name: font.resource_name.clone(),
font_size,
color: da.color.clone(),
bbox_w,
bbox_h,
quadding,
multiline: false,
std_font: Some(font.std_font),
};
let content = build_text_appearance_content(¶ms);
let font_obj_ref = next_object_ref(pdf)?;
let xobj_ref = install_normal_appearance(
pdf,
widget_ref,
content,
bbox_w,
bbox_h,
Some((font.resource_name, font.base_name, font_obj_ref)),
)?;
Ok(Some(xobj_ref))
}
fn resolve_combo_display<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
value: Vec<u8>,
) -> Vec<u8> {
let opt_val = resolve_inherited_object(pdf, widget_ref, b"Opt")
.ok()
.flatten();
let opt_arr = match resolve_opt_array(pdf, opt_val) {
Some(a) => a,
None => return value,
};
for elem_obj in opt_arr {
let elem = match elem_obj {
Object::Reference(r) => match pdf.resolve(r) {
Ok(o) => o,
Err(_) => continue,
},
other => other,
};
match elem {
Object::Array(pair) => {
let export = resolve_string_elem(pdf, pair.first().cloned());
let display = resolve_string_elem(pdf, pair.get(1).cloned());
if let (Some(exp), Some(disp)) = (export, display) {
let exp_wi = decode_pdf_text_string(&exp)
.map(|s| to_winansi_bytes(&s))
.unwrap_or(exp);
if exp_wi == value {
return decode_pdf_text_string(&disp)
.map(|s| to_winansi_bytes(&s))
.unwrap_or(disp);
}
}
}
Object::String(s) => {
let wi = decode_pdf_text_string(&s)
.map(|st| to_winansi_bytes(&st))
.unwrap_or(s);
if wi == value {
return value; }
}
_ => {}
}
}
value
}
fn resolve_opt_array<R: Read + Seek>(
pdf: &mut Pdf<R>,
opt_val: Option<Object>,
) -> Option<Vec<Object>> {
match opt_val {
Some(Object::Array(a)) => Some(a),
Some(Object::Reference(r)) => {
let resolved = pdf.resolve(r).ok()?;
match resolved {
Object::Array(a) => Some(a),
_ => None,
}
}
_ => None,
}
}
fn resolve_string_elem<R: Read + Seek>(pdf: &mut Pdf<R>, val: Option<Object>) -> Option<Vec<u8>> {
match val? {
Object::String(s) => Some(s),
Object::Reference(r) => match pdf.resolve(r).ok()? {
Object::String(s) => Some(s),
_ => None,
},
_ => None,
}
}
fn generate_list_appearance<R: Read + Seek>(
pdf: &mut Pdf<R>,
widget_ref: ObjectRef,
bbox_w: f64,
bbox_h: f64,
da: &crate::default_appearance::DefaultAppearance,
font: ChFontInfo,
) -> Result<Option<ObjectRef>> {
let opt_val = resolve_inherited_object(pdf, widget_ref, b"Opt")?;
let opt_arr = resolve_opt_array(pdf, opt_val).unwrap_or_default();
let n_opts = opt_arr.len();
struct OptEntry {
export: Vec<u8>, display: Vec<u8>, }
let mut options: Vec<OptEntry> = Vec::with_capacity(n_opts);
for elem_obj in opt_arr {
let elem = match elem_obj {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
match elem {
Object::Array(pair) => {
let exp_raw = resolve_string_elem(pdf, pair.first().cloned()).unwrap_or_default();
let disp_raw = resolve_string_elem(pdf, pair.get(1).cloned()).unwrap_or_default();
let export = decode_pdf_text_string(&exp_raw)
.map(|s| to_winansi_bytes(&s))
.unwrap_or(exp_raw);
let display = decode_pdf_text_string(&disp_raw)
.map(|s| to_winansi_bytes(&s))
.unwrap_or(disp_raw);
options.push(OptEntry { export, display });
}
Object::String(s) => {
let wi = decode_pdf_text_string(&s)
.map(|st| to_winansi_bytes(&st))
.unwrap_or(s);
options.push(OptEntry {
export: wi.clone(),
display: wi,
});
}
_ => {
options.push(OptEntry {
export: Vec::new(),
display: Vec::new(),
});
}
}
}
let selected: std::collections::BTreeSet<usize> = {
let i_val = resolve_inherited_object(pdf, widget_ref, b"I")?;
let i_arr = resolve_opt_array(pdf, i_val);
if let Some(arr) = i_arr {
let mut set = std::collections::BTreeSet::new();
for elem in arr {
let resolved = match elem {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
if let Some(idx_i64) = resolved.as_integer() {
if idx_i64 >= 0 {
let idx = idx_i64 as usize;
if idx < options.len() {
set.insert(idx);
}
}
}
}
set
} else {
let v_val = match resolve_inherited_object(pdf, widget_ref, b"V")? {
Some(Object::Reference(r)) => Some(pdf.resolve(r)?),
other => other,
};
let mut set = std::collections::BTreeSet::new();
let mut value_strings: Vec<Vec<u8>> = Vec::new();
match v_val {
Some(Object::String(s)) => value_strings.push(s),
Some(Object::Array(arr)) => {
for elem in arr {
let resolved = match elem {
Object::Reference(r) => pdf.resolve(r)?,
other => other,
};
if let Object::String(s) = resolved {
value_strings.push(s);
}
}
}
_ => {}
}
for s in value_strings {
let wi = decode_pdf_text_string(&s)
.map(|st| to_winansi_bytes(&st))
.unwrap_or(s);
for (i, opt) in options.iter().enumerate() {
if opt.export == wi {
set.insert(i);
break;
}
}
}
set
}
};
let ti_val = resolve_inherited_object(pdf, widget_ref, b"TI")?;
let ti: usize = match ti_val {
Some(Object::Reference(r)) => {
let resolved = pdf.resolve(r)?;
match resolved.as_integer() {
Some(n) if n >= 0 && (n as usize) < options.len() => n as usize,
_ => 0,
}
}
Some(Object::Integer(n)) if n >= 0 && (n as usize) < options.len() => n as usize,
_ => 0,
};
let font_size = if da.auto_size {
12.0_f64.min(bbox_h * 0.8).max(4.0)
} else {
da.font_size
};
let leading = font_size * 1.15;
let mut content: Vec<u8> = Vec::new();
content.extend_from_slice(b"q\n");
let mut any_highlight = false;
for (row, i) in (ti..options.len()).enumerate() {
let row_top = bbox_h - leading * (row as f64 + 1.0);
if row_top < -leading {
break; }
if selected.contains(&i) {
if !any_highlight {
content.extend_from_slice(b"0.6 0.75 0.85 rg\n");
any_highlight = true;
}
content.extend_from_slice(fmt_f64(0.0).as_bytes());
content.push(b' ');
content.extend_from_slice(fmt_f64(row_top).as_bytes());
content.push(b' ');
content.extend_from_slice(fmt_f64(bbox_w).as_bytes());
content.push(b' ');
content.extend_from_slice(fmt_f64(leading).as_bytes());
content.extend_from_slice(b" re\n");
content.extend_from_slice(b"f\n");
}
}
content.extend_from_slice(b"BT\n");
content.push(b'/');
crate::object::write_name_escaped(&mut content, &font.resource_name);
content.push(b' ');
content.extend_from_slice(fmt_f64(font_size).as_bytes());
content.extend_from_slice(b" Tf\n");
color_ops(&da.color, &mut content);
for (row, i) in (ti..options.len()).enumerate() {
let row_top = bbox_h - leading * (row as f64 + 1.0);
if row_top < -leading {
break;
}
let text_y = row_top + font_size * 0.2;
let text_x = 2.0_f64;
if row == 0 {
content.extend_from_slice(fmt_f64(text_x).as_bytes());
content.push(b' ');
content.extend_from_slice(fmt_f64(text_y).as_bytes());
content.extend_from_slice(b" Td\n");
} else {
content.extend_from_slice(b"0 ");
content.extend_from_slice(fmt_f64(-leading).as_bytes());
content.extend_from_slice(b" Td\n");
}
write_literal_string(&mut content, &options[i].display);
content.extend_from_slice(b" Tj\n");
}
content.extend_from_slice(b"ET\n");
content.extend_from_slice(b"Q\n");
let font_obj_ref = next_object_ref(pdf)?;
let xobj_ref = install_normal_appearance(
pdf,
widget_ref,
content,
bbox_w,
bbox_h,
Some((font.resource_name, font.base_name, font_obj_ref)),
)?;
Ok(Some(xobj_ref))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::content_stream::{ContentStreamParser, ContentToken};
use crate::writer::write_pdf;
use crate::Pdf;
use std::io::Cursor;
#[test]
fn fmt_f64_integer_no_decimal() {
assert_eq!(fmt_f64(12.0), "12");
assert_eq!(fmt_f64(0.0), "0");
assert_eq!(fmt_f64(-3.0), "-3");
}
#[test]
fn fmt_f64_strips_trailing_zeros() {
assert_eq!(fmt_f64(1.5), "1.5");
assert_eq!(fmt_f64(0.25), "0.25");
assert_eq!(fmt_f64(1.0 / 3.0), "0.3333");
}
#[test]
fn fmt_f64_non_finite_returns_zero() {
assert_eq!(fmt_f64(f64::NAN), "0");
assert_eq!(fmt_f64(f64::INFINITY), "0");
}
#[test]
fn color_ops_gray() {
let mut out = Vec::new();
color_ops(&TextColor::Gray(0.0), &mut out);
assert_eq!(out, b"0 g\n");
}
#[test]
fn color_ops_rgb() {
let mut out = Vec::new();
color_ops(&TextColor::Rgb(1.0, 0.0, 0.0), &mut out);
assert_eq!(out, b"1 0 0 rg\n");
}
#[test]
fn color_ops_cmyk() {
let mut out = Vec::new();
color_ops(&TextColor::Cmyk(0.0, 0.0, 0.0, 1.0), &mut out);
assert_eq!(out, b"0 0 0 1 k\n");
}
#[test]
fn to_winansi_ascii_passthrough() {
let out = to_winansi_bytes("Hello");
assert_eq!(out, b"Hello");
}
#[test]
fn to_winansi_latin1_passthrough() {
let out = to_winansi_bytes("caf\u{00E9}");
assert_eq!(out, b"caf\xe9");
}
#[test]
fn to_winansi_c1_range_replaced() {
let out = to_winansi_bytes("\u{0080}\u{009F}");
assert_eq!(out, b"??");
}
#[test]
fn to_winansi_beyond_latin1_replaced() {
let out = to_winansi_bytes("\u{0100}");
assert_eq!(out, b"?");
}
#[test]
fn to_winansi_cp1252_typographic_chars_mapped() {
assert_eq!(to_winansi_bytes("\u{20AC}"), b"\x80"); assert_eq!(to_winansi_bytes("\u{2019}"), b"\x92"); assert_eq!(to_winansi_bytes("\u{201C}\u{201D}"), b"\x93\x94"); assert_eq!(to_winansi_bytes("\u{2013}\u{2014}"), b"\x96\x97"); assert_eq!(to_winansi_bytes("\u{2022}"), b"\x95"); assert_eq!(to_winansi_bytes("\u{2026}"), b"\x85"); assert_eq!(to_winansi_bytes("\u{0152}\u{0153}"), b"\x8c\x9c"); assert_eq!(to_winansi_bytes("\u{2122}"), b"\x99"); }
#[test]
fn to_winansi_undefined_cp1252_slots_replaced() {
assert_eq!(to_winansi_bytes("\u{2603}"), b"?"); }
#[test]
fn official_base_name_all_variants() {
let cases = [
(StandardFont::Helvetica, b"Helvetica" as &[u8]),
(StandardFont::HelveticaBold, b"Helvetica-Bold"),
(StandardFont::HelveticaOblique, b"Helvetica-Oblique"),
(StandardFont::HelveticaBoldOblique, b"Helvetica-BoldOblique"),
(StandardFont::TimesRoman, b"Times-Roman"),
(StandardFont::TimesBold, b"Times-Bold"),
(StandardFont::TimesItalic, b"Times-Italic"),
(StandardFont::TimesBoldItalic, b"Times-BoldItalic"),
(StandardFont::Courier, b"Courier"),
(StandardFont::CourierBold, b"Courier-Bold"),
(StandardFont::CourierOblique, b"Courier-Oblique"),
(StandardFont::CourierBoldOblique, b"Courier-BoldOblique"),
(StandardFont::Symbol, b"Symbol"),
(StandardFont::ZapfDingbats, b"ZapfDingbats"),
];
for (font, expected) in cases {
assert_eq!(official_base_name(font), expected);
}
}
#[test]
fn build_text_appearance_basic_tokens() {
let params = TextAppearanceParams {
text_bytes: b"Hello".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 200.0,
bbox_h: 20.0,
quadding: 0,
multiline: false,
std_font: StandardFont::from_base_name(b"Helv"),
};
let content = build_text_appearance_content(¶ms);
let content_str = String::from_utf8_lossy(&content);
assert!(content_str.contains("/Tx BMC"), "missing /Tx BMC");
assert!(content_str.contains("EMC"), "missing EMC");
assert!(content_str.contains("BT"), "missing BT");
assert!(content_str.contains("ET"), "missing ET");
assert!(content_str.contains("/Helv 12 Tf"), "missing /Helv 12 Tf");
assert!(content_str.contains("Tj"), "missing Tj");
}
#[test]
fn build_text_appearance_escapes_font_resource_name() {
let params = TextAppearanceParams {
text_bytes: b"Hi".to_vec(),
font_resource_name: b"F A".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 100.0,
bbox_h: 20.0,
quadding: 0,
multiline: false,
std_font: StandardFont::from_base_name(b"Helv"),
};
let content = build_text_appearance_content(¶ms);
let s = String::from_utf8_lossy(&content);
assert!(s.contains("/F#20A 12 Tf"), "name not escaped: {s}");
assert!(!s.contains("/F A 12 Tf"), "raw name leaked: {s}");
}
#[test]
fn build_text_appearance_empty_value_is_valid_blank() {
let params = TextAppearanceParams {
text_bytes: Vec::new(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 100.0,
bbox_h: 20.0,
quadding: 0,
multiline: false,
std_font: StandardFont::from_base_name(b"Helv"),
};
let content = build_text_appearance_content(¶ms);
for tok in ContentStreamParser::new(&content) {
tok.expect("blank appearance must tokenize");
}
let s = String::from_utf8_lossy(&content);
assert!(s.contains("/Tx BMC") && s.contains("EMC"));
}
#[test]
fn build_text_appearance_parses_with_content_stream_parser() {
let params = TextAppearanceParams {
text_bytes: b"Test".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 10.0,
color: TextColor::Gray(0.0),
bbox_w: 150.0,
bbox_h: 18.0,
quadding: 0,
multiline: false,
std_font: StandardFont::from_base_name(b"Helv"),
};
let content = build_text_appearance_content(¶ms);
let mut found_tf = false;
let mut found_td = false;
let mut found_tj = false;
let mut tj_operand: Option<Vec<u8>> = None;
let mut tf_font_name: Option<Vec<u8>> = None;
for tok in ContentStreamParser::new(&content).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
match operator.as_slice() {
b"Tf" => {
found_tf = true;
tf_font_name = operands
.first()
.and_then(|o| o.as_name())
.map(|n| n.to_vec());
}
b"Td" => found_td = true,
b"Tj" => {
found_tj = true;
tj_operand = operands.first().and_then(|o| {
if let Object::String(bytes) = o {
Some(bytes.clone())
} else {
None
}
});
}
_ => {}
}
}
assert!(found_tf, "Tf operator not found in content stream");
assert!(found_td, "Td operator not found in content stream");
assert!(found_tj, "Tj operator not found in content stream");
assert_eq!(
tf_font_name.as_deref(),
Some(b"Helv" as &[u8]),
"Tf font name mismatch"
);
let tj_str = tj_operand.expect("Tj has no string operand");
assert_eq!(tj_str, b"Test", "Tj operand mismatch");
}
#[test]
fn word_wrap_single_word() {
let lines = word_wrap(b"Hello", 12.0, 200.0, StandardFont::from_base_name(b"Helv"));
assert_eq!(lines.len(), 1);
assert_eq!(lines[0], b"Hello");
}
#[test]
fn word_wrap_no_font_returns_single_line() {
let lines = word_wrap(b"Hello World", 12.0, 50.0, None);
assert_eq!(lines.len(), 1);
}
#[test]
fn word_wrap_preserves_leading_space() {
let font = StandardFont::from_base_name(b"Helv");
assert_eq!(word_wrap(b" hi", 12.0, 1000.0, font), vec![b" hi".to_vec()]);
assert_eq!(
word_wrap(b"a\n bc", 12.0, 1000.0, font),
vec![b"a".to_vec(), b" bc".to_vec()]
);
}
#[test]
fn word_wrap_honours_explicit_newlines() {
let font = StandardFont::from_base_name(b"Helv");
assert_eq!(
word_wrap(b"one\ntwo", 12.0, 500.0, font),
vec![b"one".to_vec(), b"two".to_vec()]
);
assert_eq!(
word_wrap(b"a\r\n\r\nb", 12.0, 500.0, font),
vec![b"a".to_vec(), Vec::new(), b"b".to_vec()]
);
}
#[test]
fn split_hard_lines_variants() {
assert_eq!(
split_hard_lines(b"a\nb"),
vec![b"a".to_vec(), b"b".to_vec()]
);
assert_eq!(
split_hard_lines(b"a\r\nb"),
vec![b"a".to_vec(), b"b".to_vec()]
);
assert_eq!(
split_hard_lines(b"a\rb"),
vec![b"a".to_vec(), b"b".to_vec()]
);
assert_eq!(split_hard_lines(b"plain"), vec![b"plain".to_vec()]);
}
fn build_minimal_tx_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (field1) \
/V (Hello World) /Rect [100 700 300 720] /P 3 0 R>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn round_trip_generate_tx_appearance() {
let raw = build_minimal_tx_pdf();
let cursor = Cursor::new(raw);
let mut pdf = Pdf::open(cursor).expect("parse minimal PDF");
let widget_ref = ObjectRef::new(4, 0);
let result = generate_text_field_appearance(&mut pdf, widget_ref);
assert!(
result.is_ok(),
"generate_text_field_appearance returned error: {:?}",
result
);
let xobj_ref = result.unwrap();
assert!(
xobj_ref.is_some(),
"generate returned None — field should be handled"
);
let xobj_ref = xobj_ref.unwrap();
let xobj = pdf.resolve(xobj_ref).expect("resolve xobj");
let Object::Stream(stream) = xobj else {
panic!("XObject is not a stream: {xobj:?}");
};
assert_eq!(
stream.dict.get("Subtype"),
Some(&Object::Name(b"Form".to_vec())),
"XObject /Subtype is not /Form"
);
let content = stream.data.clone();
let mut found_tf = false;
let mut found_tj = false;
let mut tf_name: Option<Vec<u8>> = None;
let mut tj_val: Option<Vec<u8>> = None;
for tok in ContentStreamParser::new(&content).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
match operator.as_slice() {
b"Tf" => {
found_tf = true;
tf_name = operands
.first()
.and_then(|o| o.as_name())
.map(|n| n.to_vec());
}
b"Tj" => {
found_tj = true;
if let Some(Object::String(bytes)) = operands.first() {
tj_val = Some(bytes.clone());
}
}
_ => {}
}
}
assert!(found_tf, "Tf not in appearance stream");
assert!(found_tj, "Tj not in appearance stream");
let font_name = tf_name.expect("Tf has no operand");
let resources = stream.dict.get("Resources").expect("no /Resources");
let Object::Dictionary(res_dict) = resources else {
panic!("Resources is not a dict");
};
let font_dict_obj = res_dict.get("Font").expect("no /Resources/Font");
let Object::Dictionary(font_dict) = font_dict_obj else {
panic!("Font resources is not a dict");
};
let font_key = String::from_utf8_lossy(&font_name).into_owned();
let font_obj_entry = font_dict
.get(font_key.as_str())
.unwrap_or_else(|| panic!("font key '{font_key}' not found in /Resources/Font"));
let font_obj_ref = match font_obj_entry {
Object::Reference(r) => *r,
_ => panic!("font entry is not a reference"),
};
let font_obj = pdf.resolve(font_obj_ref).expect("resolve font object");
let Object::Dictionary(fdict) = font_obj else {
panic!("font object is not a dictionary");
};
assert_eq!(
fdict.get("BaseFont"),
Some(&Object::Name(b"Helvetica".to_vec())),
"/BaseFont must be the official name 'Helvetica', not the alias 'Helv'"
);
let rendered = tj_val.expect("Tj has no string operand");
assert_eq!(rendered, b"Hello World", "Tj does not match field value");
let mut out = Vec::new();
write_pdf(&mut pdf, &mut out).expect("write_pdf");
let mut reparsed = Pdf::open(Cursor::new(out)).expect("re-parse written PDF");
let xobj2 = reparsed.resolve(xobj_ref).expect("re-resolve xobj");
assert!(
matches!(xobj2, Object::Stream(_)),
"re-parsed xobj is not a stream"
);
}
fn build_dr_font_tx_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <</Font <</F1 5 0 R>>>> /DA (/F1 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (field1) \
/V (Hi) /Rect [100 700 300 720] /P 3 0 R>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<</Type /Font /Subtype /Type1 /BaseFont /Times-Roman>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn da_font_resolves_via_dr_basefont() {
let mut pdf = Pdf::open(Cursor::new(build_dr_font_tx_pdf())).expect("parse");
let xobj_ref = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Tx field handled");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not a stream");
};
let mut tf_name: Option<Vec<u8>> = None;
for tok in ContentStreamParser::new(&stream.data).flatten() {
if let ContentToken::Op { operands, operator } = tok {
if operator == b"Tf" {
tf_name = operands
.first()
.and_then(|o| o.as_name())
.map(|n| n.to_vec());
}
}
}
assert_eq!(
tf_name.as_deref(),
Some(b"F1" as &[u8]),
"Tf name must stay F1"
);
let Object::Dictionary(res) = stream.dict.get("Resources").expect("resources") else {
panic!("resources not dict");
};
let Object::Dictionary(fonts) = res.get("Font").expect("font dict") else {
panic!("font not dict");
};
let font_ref = match fonts.get("F1").expect("F1 entry") {
Object::Reference(r) => *r,
other => panic!("F1 not a ref: {other:?}"),
};
let Object::Dictionary(fdict) = pdf.resolve(font_ref).expect("resolve font") else {
panic!("font obj not dict");
};
assert_eq!(
fdict.get("BaseFont"),
Some(&Object::Name(b"Times-Roman".to_vec())),
"BaseFont must resolve from /DR to Times-Roman"
);
}
fn build_btn_widget_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk) /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn build_btn_pdf_obj4(obj4_body: &str) -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(format!("4 0 obj\n{obj4_body}\nendobj\n").as_bytes());
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn btn_on_state_content(pdf_bytes: Vec<u8>) -> (Object, Vec<u8>) {
let mut pdf = Pdf::open(Cursor::new(pdf_bytes)).expect("parse");
let on_ref = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let ap_n = match pdf.resolve(ObjectRef::new(4, 0)).expect("widget") {
Object::Dictionary(w) => match w.get("AP") {
Some(Object::Dictionary(ap)) => ap.get("N").cloned(),
_ => None,
},
_ => None,
};
let Object::Stream(on) = pdf.resolve(on_ref).expect("on xobj") else {
panic!("on xobj not a stream");
};
(ap_n.expect("AP/N present"), on.data)
}
#[test]
fn btn_negative_ff_falls_back_to_checkbox_not_pushbutton() {
let pdf = build_btn_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Btn /T (c) /Ff -1 /Rect [10 10 30 30]>>",
);
let (ap_n, content) = btn_on_state_content(pdf);
assert!(
matches!(ap_n, Object::Dictionary(_)),
"negative /Ff must take the checkbox path (/AP/N is a state dict), got: {ap_n:?}"
);
assert!(
String::from_utf8_lossy(&content).contains("/ZaDb"),
"checkbox on-state must render in ZapfDingbats"
);
}
#[test]
fn btn_checkbox_mk_ca_utf16be_is_decoded() {
let pdf = build_btn_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Btn /T (c) /MK <</CA <FEFF0034>>> /Rect [10 10 30 30]>>",
);
let (_ap_n, content) = btn_on_state_content(pdf);
let mut tj_bytes: Option<Vec<u8>> = None;
for tok in ContentStreamParser::new(&content).flatten() {
if let ContentToken::Op { operands, operator } = tok {
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
tj_bytes = Some(s.clone());
}
}
}
}
assert_eq!(
tj_bytes.as_deref(),
Some(b"4" as &[u8]),
"UTF-16BE /MK/CA must decode to the ZapfDingbats code byte 0x34"
);
}
fn build_tx_no_value_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) /DA (/Helv 12 Tf 0 g) /Rect [10 10 100 30]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n\
{:010} 00000 n \n",
off1, off2, off3, off4,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn non_tx_field_returns_none() {
let mut pdf = Pdf::open(Cursor::new(build_btn_widget_pdf())).expect("parse");
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(result.unwrap().is_none(), "non-Tx field should return None");
}
#[test]
fn missing_value_returns_none() {
let mut pdf = Pdf::open(Cursor::new(build_tx_no_value_pdf())).expect("parse");
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(result.unwrap().is_none(), "missing /V should return None");
}
#[test]
fn acroform_da_fallback_used_when_field_has_none() {
let raw = build_minimal_tx_pdf(); let cursor = Cursor::new(raw);
let mut pdf = Pdf::open(cursor).expect("parse");
let widget_ref = ObjectRef::new(4, 0);
let result = generate_text_field_appearance(&mut pdf, widget_ref)
.expect("generate should not error");
assert!(
result.is_some(),
"should produce appearance via AcroForm /DA fallback"
);
}
#[test]
fn multiline_td_x_offsets_are_deltas_not_absolute() {
let params = TextAppearanceParams {
text_bytes: b"one two three".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 10.0,
color: TextColor::Gray(0.0),
bbox_w: 30.0, bbox_h: 60.0,
quadding: 0, multiline: true,
std_font: StandardFont::from_base_name(b"Helv"),
};
let content = build_text_appearance_content(¶ms);
let mut td_ops: Vec<(f64, f64)> = Vec::new();
for tok in ContentStreamParser::new(&content).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator.as_slice() == b"Td" {
if let (Some(x_obj), Some(y_obj)) = (operands.first(), operands.get(1)) {
let x = x_obj
.as_real()
.or_else(|| x_obj.as_integer().map(|i| i as f64));
let y = y_obj
.as_real()
.or_else(|| y_obj.as_integer().map(|i| i as f64));
if let (Some(x), Some(y)) = (x, y) {
td_ops.push((x, y));
}
}
}
}
assert!(
td_ops.len() >= 3,
"expected at least 3 Td ops for 3 wrapped lines, got {}",
td_ops.len()
);
let (x0, y0) = td_ops[0];
assert!(
(x0 - 2.0).abs() < 0.01,
"first Td x should be 2.0, got {x0}"
);
assert!(
y0 > 0.0,
"first Td y should be positive (first_y), got {y0}"
);
for (i, &(x, y)) in td_ops[1..].iter().enumerate() {
assert!(
x.abs() < 0.01,
"Td[{}] x (delta) should be 0.0 for left-align, got {x}",
i + 1
);
assert!(
y < 0.0,
"Td[{}] y should be negative (down-move), got {y}",
i + 1
);
}
}
fn build_pdf_with_indirect_field_props() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT 5 0 R /Q 6 0 R /T (field1) \
/V (Hello World) /Rect [100 700 300 720] /P 3 0 R>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n/Tx\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n1\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 7\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 7 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_inherited_name_follows_indirect_reference() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let ft = resolve_inherited_name(&mut pdf, ObjectRef::new(4, 0), b"FT").unwrap();
assert_eq!(ft.as_deref(), Some(b"Tx" as &[u8]));
}
#[test]
fn resolve_inherited_integer_follows_indirect_reference() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let q = resolve_inherited_integer(&mut pdf, ObjectRef::new(4, 0), b"Q").unwrap();
assert_eq!(q, Some(1));
}
#[test]
fn generate_appearance_recognizes_indirect_ft() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(
result.is_some(),
"indirect /FT /Tx must be resolved so the field is not skipped"
);
}
#[test]
fn compute_x_offset_center_quadding() {
let params = TextAppearanceParams {
text_bytes: b"Hi".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 200.0,
bbox_h: 20.0,
quadding: 1,
multiline: false,
std_font: StandardFont::from_base_name(b"Helvetica"),
};
let x = compute_x_offset(¶ms, ¶ms.text_bytes);
assert!(
x > 2.0,
"center quadding x offset should exceed 2.0, got {x}"
);
assert!(x < 100.0, "center quadding x should be < 100, got {x}");
}
#[test]
fn compute_x_offset_right_quadding() {
let params = TextAppearanceParams {
text_bytes: b"Hi".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 200.0,
bbox_h: 20.0,
quadding: 2,
multiline: false,
std_font: StandardFont::from_base_name(b"Helvetica"),
};
let x = compute_x_offset(¶ms, ¶ms.text_bytes);
assert!(
x > 2.0,
"right quadding x offset should exceed 2.0, got {x}"
);
assert!(x < 198.0, "right quadding x should be < 198, got {x}");
}
#[test]
fn compute_x_offset_center_no_font_clamps_to_2() {
let params = TextAppearanceParams {
text_bytes: b"Hi".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 0.0, bbox_h: 20.0,
quadding: 1,
multiline: false,
std_font: None,
};
let x = compute_x_offset(¶ms, ¶ms.text_bytes);
assert!(
(x - 2.0).abs() < 0.001,
"degenerate centre should clamp to 2.0, got {x}"
);
}
#[test]
fn compute_x_offset_right_no_font_clamps_to_2() {
let params = TextAppearanceParams {
text_bytes: b"Hi".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 0.0, bbox_h: 20.0,
quadding: 2,
multiline: false,
std_font: None,
};
let x = compute_x_offset(¶ms, ¶ms.text_bytes);
assert!(
(x - 2.0).abs() < 0.001,
"degenerate right should clamp to 2.0, got {x}"
);
}
#[test]
fn build_text_appearance_center_quadding_has_td() {
let params = TextAppearanceParams {
text_bytes: b"Test".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 200.0,
bbox_h: 20.0,
quadding: 1,
multiline: false,
std_font: StandardFont::from_base_name(b"Helvetica"),
};
let content = build_text_appearance_content(¶ms);
let s = String::from_utf8_lossy(&content);
assert!(s.contains("Td"), "center quadding must emit a Td operator");
assert!(s.contains("Tj"), "center quadding must emit a Tj operator");
}
#[test]
fn build_text_appearance_right_quadding_has_td() {
let params = TextAppearanceParams {
text_bytes: b"Test".to_vec(),
font_resource_name: b"Helv".to_vec(),
font_size: 12.0,
color: TextColor::Gray(0.0),
bbox_w: 200.0,
bbox_h: 20.0,
quadding: 2,
multiline: false,
std_font: StandardFont::from_base_name(b"Helvetica"),
};
let content = build_text_appearance_content(¶ms);
let s = String::from_utf8_lossy(&content);
assert!(s.contains("Td"), "right quadding must emit a Td operator");
assert!(s.contains("Tj"), "right quadding must emit a Tj operator");
}
#[test]
fn word_wrap_zero_max_width_returns_whole_text() {
let lines = word_wrap(
b"Hello World",
12.0,
0.0,
StandardFont::from_base_name(b"Helv"),
);
assert_eq!(lines.len(), 1);
assert_eq!(lines[0], b"Hello World");
}
#[test]
fn word_wrap_negative_max_width_returns_whole_text() {
let lines = word_wrap(
b"Hello World",
12.0,
-1.0,
StandardFont::from_base_name(b"Helv"),
);
assert_eq!(lines.len(), 1);
assert_eq!(lines[0], b"Hello World");
}
#[test]
fn word_wrap_empty_text_returns_one_empty_line() {
let lines = word_wrap(b"", 12.0, 200.0, StandardFont::from_base_name(b"Helv"));
assert_eq!(lines.len(), 1);
assert_eq!(lines[0], b"");
}
#[test]
fn to_winansi_remaining_cp1252_chars() {
assert_eq!(to_winansi_bytes("\u{201A}"), b"\x82"); assert_eq!(to_winansi_bytes("\u{0192}"), b"\x83"); assert_eq!(to_winansi_bytes("\u{201E}"), b"\x84"); assert_eq!(to_winansi_bytes("\u{2020}"), b"\x86"); assert_eq!(to_winansi_bytes("\u{2021}"), b"\x87"); assert_eq!(to_winansi_bytes("\u{02C6}"), b"\x88"); assert_eq!(to_winansi_bytes("\u{2030}"), b"\x89"); assert_eq!(to_winansi_bytes("\u{0160}"), b"\x8A"); assert_eq!(to_winansi_bytes("\u{2039}"), b"\x8B"); assert_eq!(to_winansi_bytes("\u{017D}"), b"\x8E"); assert_eq!(to_winansi_bytes("\u{2018}"), b"\x91"); assert_eq!(to_winansi_bytes("\u{201D}"), b"\x94"); assert_eq!(to_winansi_bytes("\u{2013}"), b"\x96"); assert_eq!(to_winansi_bytes("\u{02DC}"), b"\x98"); assert_eq!(to_winansi_bytes("\u{0161}"), b"\x9A"); assert_eq!(to_winansi_bytes("\u{203A}"), b"\x9B"); assert_eq!(to_winansi_bytes("\u{017E}"), b"\x9E"); assert_eq!(to_winansi_bytes("\u{0178}"), b"\x9F"); }
#[test]
fn fmt_f64_small_negative_rounds_to_minus_zero() {
assert_eq!(fmt_f64(-0.00001), "-0");
}
fn build_pdf_with_indirect_rect() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V (text) /Rect 5 0 R>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n[100 700 300 720]\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_rect_follows_indirect_reference() {
let raw = build_pdf_with_indirect_rect();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let rect = resolve_rect(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(
rect.is_some(),
"indirect /Rect must resolve to Some(PageBox)"
);
let r = rect.unwrap();
assert!((r.llx - 100.0).abs() < 0.001);
assert!((r.ury - 720.0).abs() < 0.001);
}
#[test]
fn generate_appearance_with_indirect_rect() {
let raw = build_pdf_with_indirect_rect();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(
result.unwrap().is_some(),
"indirect /Rect must not cause None"
);
}
fn build_pdf_with_short_rect() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V (text) /Rect [100 700 300]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_rect_short_array_returns_none() {
let raw = build_pdf_with_short_rect();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let rect = resolve_rect(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(rect.is_none(), "3-element /Rect must return None");
}
#[test]
fn generate_appearance_short_rect_returns_none() {
let raw = build_pdf_with_short_rect();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(result.unwrap().is_none(), "short /Rect must cause None");
}
fn build_pdf_with_nonnumeric_rect() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V (text) /Rect [100 700 /Bad 720]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_rect_nonnumeric_element_returns_none() {
let raw = build_pdf_with_nonnumeric_rect();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let rect = resolve_rect(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(
rect.is_none(),
"non-numeric element in /Rect must return None"
);
}
#[test]
fn resolve_rect_non_dict_object_returns_none() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let rect = resolve_rect(&mut pdf, ObjectRef::new(5, 0)).unwrap();
assert!(
rect.is_none(),
"non-dict object must return None from resolve_rect"
);
}
fn build_pdf_with_field_da() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Courier 10 Tf 0 g) /V (FieldDA) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_da_field_level_takes_precedence() {
let raw = build_pdf_with_field_da();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let da = resolve_da(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(da.is_some(), "field-level /DA must be found");
let da_bytes = da.unwrap();
assert!(
da_bytes.starts_with(b"/Courier"),
"field /DA should be /Courier, got: {:?}",
String::from_utf8_lossy(&da_bytes)
);
}
fn build_pdf_with_indirect_da() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA 5 0 R /V (IndirectDA) /Rect [10 10 200 30]>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n(/Times-Roman 10 Tf 0 g)\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_da_indirect_reference() {
let raw = build_pdf_with_indirect_da();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let da = resolve_da(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(da.is_some(), "indirect /DA must resolve to Some");
let da_bytes = da.unwrap();
assert!(
da_bytes.contains(&b'T'),
"indirect /DA value must include 'T', got: {:?}",
String::from_utf8_lossy(&da_bytes)
);
}
fn build_pdf_with_indirect_acroform_da() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA 5 0 R>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/V (AcroDA) /Rect [10 10 200 30]>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n(/Helv 12 Tf 0 g)\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_da_acroform_indirect_da() {
let raw = build_pdf_with_indirect_acroform_da();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let da = resolve_da(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(da.is_some(), "AcroForm indirect /DA must resolve to Some");
}
fn build_pdf_with_no_da() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>>>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/V (NoDA) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_da_none_when_no_da_anywhere() {
let raw = build_pdf_with_no_da();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let da = resolve_da(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(da.is_none(), "no /DA anywhere must return None");
}
#[test]
fn generate_appearance_with_no_da_uses_empty_da() {
let raw = build_pdf_with_no_da();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok(), "no /DA must not cause error");
assert!(
result.unwrap().is_some(),
"no /DA must still produce appearance"
);
}
fn build_pdf_with_indirect_v() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/V 5 0 R /Rect [10 10 200 30]>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n(IndirectValue)\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn generate_appearance_with_indirect_v() {
let raw = build_pdf_with_indirect_v();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok(), "indirect /V must not cause error");
assert!(
result.unwrap().is_some(),
"indirect /V must produce appearance"
);
}
#[test]
fn install_normal_appearance_without_font_resource() {
let raw = build_minimal_tx_pdf();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let widget_ref = ObjectRef::new(4, 0);
let content = b"q Q".to_vec();
let result = install_normal_appearance(&mut pdf, widget_ref, content, 200.0, 20.0, None);
assert!(result.is_ok(), "install without font resource must succeed");
let xobj_ref = result.unwrap();
let xobj = pdf.resolve(xobj_ref).unwrap();
if let Object::Stream(s) = xobj {
assert!(
s.dict.get("Resources").is_none(),
"no font resource → no /Resources key in xobj"
);
}
}
fn build_pdf_with_existing_ap() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/V (text) /Rect [10 10 200 30] /AP <</N 5 0 R>>>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(
b"5 0 obj\n<</Type /XObject /Subtype /Form /FormType 1 \
/BBox [0 0 190 20]>>\nstream\nq Q\nendstream\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn generate_appearance_replaces_existing_ap() {
let raw = build_pdf_with_existing_ap();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok(), "existing /AP must not cause error");
assert!(
result.unwrap().is_some(),
"existing /AP must still produce new appearance"
);
}
#[test]
fn resolve_inherited_object_indirect_reference() {
let raw = build_pdf_with_indirect_v();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let val = resolve_inherited_object(&mut pdf, ObjectRef::new(4, 0), b"V").unwrap();
assert!(
val.is_some(),
"indirect /V must not return None from resolve_inherited_object"
);
}
#[test]
fn lookup_dr_basefont_no_dr_returns_none() {
let raw = build_minimal_tx_pdf();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let sf = lookup_dr_basefont(&mut pdf, ObjectRef::new(4, 0), b"UnknownFont").unwrap();
assert!(sf.is_none(), "empty /DR must return None");
}
fn build_pdf_with_field_dr_font() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/MyFont 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DR <</Font <</MyFont <</Type /Font /Subtype /Type1 /BaseFont /Courier-Bold>>>>>> \
/V (FieldDR) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn lookup_dr_basefont_field_level_dr() {
let raw = build_pdf_with_field_dr_font();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let sf = lookup_dr_basefont(&mut pdf, ObjectRef::new(4, 0), b"MyFont").unwrap();
assert!(
sf.is_some(),
"field-level /DR /Font must resolve to a StandardFont"
);
assert_eq!(
sf.unwrap(),
StandardFont::CourierBold,
"must resolve to Courier-Bold"
);
}
#[test]
fn generate_appearance_field_level_dr_font() {
let raw = build_pdf_with_field_dr_font();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(
result.unwrap().is_some(),
"field-level /DR font must produce appearance"
);
}
fn build_pdf_multiline_tx() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/Ff 4096 /V (one two three four) /Rect [10 10 50 100]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn generate_multiline_appearance() {
let raw = build_pdf_multiline_tx();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok(), "multiline /Ff must not cause error");
let xobj_ref = result.unwrap();
assert!(
xobj_ref.is_some(),
"multiline field must produce appearance"
);
let xobj_ref = xobj_ref.unwrap();
let obj = pdf.resolve(xobj_ref).unwrap();
if let Object::Stream(s) = obj {
let content = String::from_utf8_lossy(&s.data);
let td_count = content.matches("Td").count();
assert!(
td_count >= 1,
"multiline must have Td operators, got {td_count}"
);
}
}
fn build_pdf_with_quadding(q: i64) -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
let widget = format!(
"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/Q {q} /V (Center) /Rect [10 10 200 30]>>\nendobj\n"
);
pdf.extend_from_slice(widget.as_bytes());
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn generate_appearance_center_quadding() {
let raw = build_pdf_with_quadding(1);
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(result.unwrap().is_some(), "Q=1 must produce appearance");
}
#[test]
fn generate_appearance_right_quadding() {
let raw = build_pdf_with_quadding(2);
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(result.unwrap().is_some(), "Q=2 must produce appearance");
}
fn build_pdf_with_parent_cycle() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R>>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<</Type /Annot /FT /Tx /T (f) /Parent 7 0 R>>\nendobj\n");
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"5 0 obj\n(dummy)\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n(dummy)\nendobj\n");
let off7 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\n<</FT /Tx /Parent 4 0 R>>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 8\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n\
{off7:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 8 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_da_cycle_returns_none() {
let raw = build_pdf_with_parent_cycle();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let da = resolve_da(&mut pdf, ObjectRef::new(4, 0)).unwrap();
assert!(da.is_none(), "cycle in /Parent chain must return None");
assert!(
pdf.repair_diagnostics().entries().iter().any(|d| {
d.severity == crate::Severity::Warning && d.message.contains("cycle detected")
}),
"a cycle in the /DA parent chain must record a warning, got: {:?}",
pdf.repair_diagnostics().entries()
);
}
#[test]
fn resolve_inherited_name_cycle_returns_none() {
let raw = build_pdf_with_parent_cycle();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = resolve_inherited_name(&mut pdf, ObjectRef::new(4, 0), b"DA").unwrap();
assert!(
result.is_none(),
"cycle must return None for resolve_inherited_name"
);
}
#[test]
fn resolve_inherited_object_cycle_returns_none() {
let raw = build_pdf_with_parent_cycle();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = resolve_inherited_object(&mut pdf, ObjectRef::new(4, 0), b"DA").unwrap();
assert!(
result.is_none(),
"cycle must return None for resolve_inherited_object"
);
}
#[test]
fn resolve_inherited_integer_cycle_returns_none() {
let raw = build_pdf_with_parent_cycle();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = resolve_inherited_integer(&mut pdf, ObjectRef::new(4, 0), b"Q").unwrap();
assert!(
result.is_none(),
"cycle must return None for resolve_inherited_integer"
);
}
#[test]
fn resolve_inherited_name_non_dict_node_errors() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = resolve_inherited_name(&mut pdf, ObjectRef::new(5, 0), b"FT");
assert!(
result.is_err(),
"non-dict node must return Err from resolve_inherited_name"
);
}
#[test]
fn resolve_inherited_object_non_dict_node_errors() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = resolve_inherited_object(&mut pdf, ObjectRef::new(5, 0), b"V");
assert!(
result.is_err(),
"non-dict node must return Err from resolve_inherited_object"
);
}
#[test]
fn resolve_inherited_integer_non_dict_node_errors() {
let raw = build_pdf_with_indirect_field_props();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = resolve_inherited_integer(&mut pdf, ObjectRef::new(5, 0), b"Q");
assert!(
result.is_err(),
"non-dict node must return Err from resolve_inherited_integer"
);
}
fn build_pdf_autosize_tx() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 0 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/V (AutoSize) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn generate_appearance_autosize_font() {
let raw = build_pdf_autosize_tx();
let mut pdf = Pdf::open(Cursor::new(raw)).unwrap();
let result = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok(), "auto-size /DA must not cause error");
assert!(
result.unwrap().is_some(),
"auto-size must produce appearance"
);
}
use crate::generate_button_field_appearance;
#[test]
fn btn_non_btn_field_returns_none() {
let raw = build_tx_no_value_pdf();
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(
result.unwrap().is_none(),
"Tx field must return None from Btn generator"
);
}
#[test]
fn btn_degenerate_rect_returns_none() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk) /Rect [10 10 10 30]>>\nendobj\n");
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(
result.unwrap().is_none(),
"degenerate rect should return None"
);
}
#[test]
fn btn_pushbutton_ff_bit17_detected() {
let ff_pushbutton = 0x10000_i64; let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
let widget_bytes = format!(
"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (pb) \
/Ff {} /MK <</CA (OK)>> /Rect [10 10 80 30]>>\nendobj\n",
ff_pushbutton
);
raw.extend_from_slice(widget_bytes.as_bytes());
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("generate");
let xobj_ref = result.expect("pushbutton must produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap_dict) = wdict.get("AP").expect("AP missing").clone() else {
panic!("AP not dict")
};
let n_val = ap_dict.get("N").expect("N missing");
assert!(
matches!(n_val, Object::Reference(_)),
"/AP/N must be a reference for pushbutton"
);
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream")
};
let content_str = String::from_utf8_lossy(&stream.data);
assert!(
content_str.contains("/Helv"),
"pushbutton must use Helv font"
);
assert!(
content_str.contains("Tf"),
"pushbutton must have Tf operator"
);
let mut found_caption = false;
for tok in ContentStreamParser::new(&stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"OK" {
found_caption = true;
}
}
}
}
assert!(found_caption, "pushbutton Tj must contain caption 'OK'");
}
#[test]
fn btn_checkbox_ap_has_on_and_off_states() {
let mut pdf = Pdf::open(Cursor::new(build_btn_widget_pdf())).expect("parse");
let result =
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("generate");
let on_ref = result.expect("checkbox must produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap) = wdict.get("AP").expect("AP missing").clone() else {
panic!("AP not dict")
};
let n_val = ap.get("N").expect("N missing");
let Object::Dictionary(n_dict) = n_val else {
panic!("N is not a dict for checkbox (should be state dict), got: {n_val:?}");
};
let yes_ref = match n_dict.get("Yes").expect("Yes key missing") {
Object::Reference(r) => *r,
other => panic!("Yes is not a ref: {other:?}"),
};
let off_ref_n = match n_dict.get("Off").expect("Off key missing") {
Object::Reference(r) => *r,
other => panic!("Off is not a ref: {other:?}"),
};
assert_eq!(on_ref, yes_ref, "returned on_ref must match /AP/N/Yes ref");
assert_ne!(yes_ref, off_ref_n, "on and off refs must differ");
let d_val = ap.get("D").expect("D missing");
let Object::Dictionary(d_dict) = d_val else {
panic!("D is not a dict")
};
assert!(d_dict.get("Yes").is_some(), "/AP/D must have Yes key");
assert!(d_dict.get("Off").is_some(), "/AP/D must have Off key");
let Object::Stream(on_stream) = pdf.resolve(on_ref).expect("resolve on xobj") else {
panic!("on xobj not stream")
};
let on_str = String::from_utf8_lossy(&on_stream.data);
assert!(
on_str.contains("/ZaDb"),
"on stream must contain /ZaDb font ref"
);
assert!(on_str.contains("Tf"), "on stream must have Tf operator");
let mut found_glyph = false;
for tok in ContentStreamParser::new(&on_stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"4" {
found_glyph = true;
}
}
}
}
assert!(found_glyph, "checkbox on stream Tj must contain glyph '4'");
let Object::Stream(off_stream) = pdf.resolve(off_ref_n).expect("resolve off xobj") else {
panic!("off xobj not stream")
};
let off_str = String::from_utf8_lossy(&off_stream.data);
assert!(!off_str.contains("Tj"), "off stream must not contain Tj");
assert_eq!(
wdict.get("AS"),
Some(&Object::Name(b"Off".to_vec())),
"/AS must be /Off for a new checkbox"
);
}
#[test]
fn btn_radio_uses_bullet_glyph() {
let ff_radio = 0x8000_i64; let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
let widget_bytes = format!(
"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (rb) \
/Ff {} /Rect [10 10 30 30]>>\nendobj\n",
ff_radio
);
raw.extend_from_slice(widget_bytes.as_bytes());
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let on_ref = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("radio must produce appearance");
let Object::Stream(on_stream) = pdf.resolve(on_ref).expect("resolve on") else {
panic!("not stream")
};
let mut found = false;
for tok in ContentStreamParser::new(&on_stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"l" {
found = true;
}
}
}
}
assert!(found, "radio on stream Tj must contain glyph 'l'");
}
#[test]
fn btn_on_state_name_from_existing_ap_n_dict() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n<</Type /XObject /Subtype /Form /FormType 1 /BBox [0 0 20 20]>>\nstream\nq Q\nendstream\nendobj\n");
let off6 = raw.len() as u64;
raw.extend_from_slice(b"6 0 obj\n<</Type /XObject /Subtype /Form /FormType 1 /BBox [0 0 20 20]>>\nstream\nq Q\nendstream\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk2) \
/AP << /N << /On 5 0 R /Off 6 0 R >> >> /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 7\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n\
{off3:010} 00000 n \n{off4:010} 00000 n \n{off5:010} 00000 n \n{off6:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 7 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("should produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap) = wdict.get("AP").expect("AP").clone() else {
panic!("AP not dict")
};
let Object::Dictionary(n_dict) = ap.get("N").expect("N") else {
panic!("N not dict")
};
assert!(
n_dict.get("On").is_some(),
"/AP/N must have 'On' key (from pre-existing)"
);
assert!(n_dict.get("Off").is_some(), "/AP/N must have 'Off' key");
assert!(
n_dict.get("Yes").is_none(),
"/AP/N must not have 'Yes' when 'On' was pre-existing"
);
}
#[test]
fn btn_on_state_name_from_as() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk3) \
/AS /Checked /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("should produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap) = wdict.get("AP").expect("AP").clone() else {
panic!("AP not dict")
};
let Object::Dictionary(n_dict) = ap.get("N").expect("N") else {
panic!("N not dict")
};
assert!(
n_dict.get("Checked").is_some(),
"/AP/N must have 'Checked' key from /AS"
);
assert!(n_dict.get("Off").is_some(), "/AP/N must have 'Off' key");
}
#[test]
fn btn_mk_ca_overrides_default_glyph() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk4) \
/MK <</CA (8)>> /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let on_ref = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("should produce appearance");
let Object::Stream(on_stream) = pdf.resolve(on_ref).expect("resolve on") else {
panic!("not stream")
};
let mut found_glyph = false;
for tok in ContentStreamParser::new(&on_stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"8" {
found_glyph = true;
}
}
}
}
assert!(
found_glyph,
"/MK/CA '8' must appear in Tj, overriding default '4'"
);
}
#[test]
fn btn_checkbox_object_refs_are_distinct() {
let mut pdf = Pdf::open(Cursor::new(build_btn_widget_pdf())).expect("parse");
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap) = wdict.get("AP").expect("AP").clone() else {
panic!("AP not dict")
};
let Object::Dictionary(n_dict) = ap.get("N").expect("N") else {
panic!("N not dict")
};
let on_ref = match n_dict.get("Yes").expect("Yes") {
Object::Reference(r) => *r,
other => panic!("Yes not ref: {other:?}"),
};
let off_ref = match n_dict.get("Off").expect("Off") {
Object::Reference(r) => *r,
other => panic!("Off not ref: {other:?}"),
};
let Object::Stream(on_stream) = pdf.resolve(on_ref).expect("resolve on") else {
panic!("on not stream")
};
let Object::Stream(off_stream) = pdf.resolve(off_ref).expect("resolve off") else {
panic!("off not stream")
};
let get_zadb_ref = |sdict: &Dictionary| -> ObjectRef {
let Object::Dictionary(res) = sdict.get("Resources").expect("resources") else {
panic!("resources not dict")
};
let Object::Dictionary(fonts) = res.get("Font").expect("Font") else {
panic!("Font not dict")
};
match fonts.get("ZaDb").expect("ZaDb") {
Object::Reference(r) => *r,
other => panic!("ZaDb not ref: {other:?}"),
}
};
let font_ref_on = get_zadb_ref(&on_stream.dict);
let font_ref_off = get_zadb_ref(&off_stream.dict);
assert_ne!(on_ref, off_ref, "on and off refs must differ");
assert_ne!(on_ref, font_ref_on, "on ref must differ from font ref");
assert_ne!(off_ref, font_ref_on, "off ref must differ from font ref");
assert_eq!(
font_ref_on, font_ref_off,
"on and off streams must share font ref"
);
}
#[test]
fn btn_zapf_font_dict_has_no_encoding() {
let mut pdf = Pdf::open(Cursor::new(build_btn_widget_pdf())).expect("parse");
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap) = wdict.get("AP").expect("AP").clone() else {
panic!("AP not dict")
};
let Object::Dictionary(n_dict) = ap.get("N").expect("N") else {
panic!("N not dict")
};
let on_ref = match n_dict.get("Yes").expect("Yes") {
Object::Reference(r) => *r,
other => panic!("Yes not ref: {other:?}"),
};
let Object::Stream(on_stream) = pdf.resolve(on_ref).expect("resolve on") else {
panic!("not stream")
};
let Object::Dictionary(res) = on_stream.dict.get("Resources").expect("resources") else {
panic!("not dict")
};
let Object::Dictionary(fonts) = res.get("Font").expect("Font") else {
panic!("not dict")
};
let font_ref = match fonts.get("ZaDb").expect("ZaDb") {
Object::Reference(r) => *r,
other => panic!("ZaDb not ref: {other:?}"),
};
let Object::Dictionary(fdict) = pdf.resolve(font_ref).expect("resolve font") else {
panic!("font not dict")
};
assert!(
fdict.get("Encoding").is_none(),
"ZapfDingbats font dict must NOT have /Encoding, got: {:?}",
fdict.get("Encoding")
);
assert_eq!(
fdict.get("BaseFont"),
Some(&Object::Name(b"ZapfDingbats".to_vec())),
"font dict BaseFont must be ZapfDingbats"
);
}
#[test]
fn btn_checkbox_round_trip() {
let mut pdf = Pdf::open(Cursor::new(build_btn_widget_pdf())).expect("parse");
let on_ref = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let mut out = Vec::new();
write_pdf(&mut pdf, &mut out).expect("write_pdf");
let mut pdf2 = Pdf::open(Cursor::new(out)).expect("re-parse");
let widget_obj = pdf2.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let ap_obj = wdict.get("AP").expect("/AP missing after round-trip");
assert!(
matches!(ap_obj, Object::Dictionary(_)),
"/AP must be a dict after round-trip"
);
let xobj2 = pdf2.resolve(on_ref).expect("re-resolve on xobj");
assert!(
matches!(xobj2, Object::Stream(_)),
"on xobj must be a stream after round-trip"
);
}
use crate::generate_choice_field_appearance;
fn build_combo_pdf(value: &str, ff: i64) -> Vec<u8> {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
let widget = format!(
"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Ch /T (sel) \
/Ff {} /V ({}) /DA (/Helv 12 Tf 0 g) \
/Rect [100 700 300 720]>>\nendobj\n",
ff, value
);
raw.extend_from_slice(widget.as_bytes());
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
fn build_list_pdf(opts_str: &str, sel_i_str: &str, sel_v_str: &str) -> Vec<u8> {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
let ff = 0_i64; let i_entry = if sel_i_str.is_empty() {
String::new()
} else {
format!("/I {sel_i_str} ")
};
let v_entry = if sel_v_str.is_empty() {
String::new()
} else {
format!("/V {sel_v_str} ")
};
let widget = format!(
"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Ch /T (list) \
/Ff {} /Opt [{opts_str}] {i_entry}{v_entry}\
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>\nendobj\n",
ff
);
raw.extend_from_slice(widget.as_bytes());
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
fn build_inherited_opt_list_pdf() -> Vec<u8> {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [5 0 R] /DR <<>> /DA (/Helv 10 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /Parent 5 0 R \
/Rect [100 600 300 700]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(
b"5 0 obj\n<</FT /Ch /T (list) /Ff 0 /Opt [(Red) (Green) (Blue)] \
/V (Green) /Kids [4 0 R]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n0000000000 65535 f \n\
{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n\
{off4:010} 00000 n \n{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
#[test]
fn ch_list_inherits_opt_from_parent_field() {
let mut pdf = Pdf::open(Cursor::new(build_inherited_opt_list_pdf())).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Ch widget handled");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not a stream");
};
let mut tj_strings: Vec<Vec<u8>> = Vec::new();
for tok in ContentStreamParser::new(&stream.data).flatten() {
if let ContentToken::Op { operands, operator } = tok {
if operator == b"Tj" {
if let Some(Object::String(b)) = operands.first() {
tj_strings.push(b.clone());
}
}
}
}
assert!(
tj_strings.iter().any(|s| s == b"Red")
&& tj_strings.iter().any(|s| s == b"Green")
&& tj_strings.iter().any(|s| s == b"Blue"),
"inherited /Opt not rendered: {tj_strings:?}"
);
}
fn build_inherited_i_list_pdf() -> Vec<u8> {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [5 0 R] /DR <<>> /DA (/Helv 10 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /Parent 5 0 R \
/Rect [100 600 300 700]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(
b"5 0 obj\n<</FT /Ch /T (list) /Ff 0 /Opt [(Red) (Green) (Blue)] \
/I [1] /Kids [4 0 R]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n0000000000 65535 f \n\
{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n\
{off4:010} 00000 n \n{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
#[test]
fn ch_list_inherits_i_from_parent_field() {
let mut pdf = Pdf::open(Cursor::new(build_inherited_i_list_pdf())).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Ch widget handled");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not a stream");
};
let mut saw_re = false;
let mut saw_fill = false;
for tok in ContentStreamParser::new(&stream.data).flatten() {
if let ContentToken::Op { operator, .. } = tok {
if operator == b"re" {
saw_re = true;
} else if operator == b"f" && saw_re {
saw_fill = true;
}
}
}
assert!(
saw_fill,
"inherited /I did not produce a selection highlight"
);
}
fn build_indirect_array_v_list_pdf() -> Vec<u8> {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 10 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /V 5 0 R \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n[(Red) (Blue)]\nendobj\n");
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n0000000000 65535 f \n\
{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n\
{off4:010} 00000 n \n{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
#[test]
fn ch_list_indirect_array_v_highlights_multiselect() {
let mut pdf = Pdf::open(Cursor::new(build_indirect_array_v_list_pdf())).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Ch widget handled");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not a stream");
};
let fills = ContentStreamParser::new(&stream.data)
.flatten()
.filter(|t| matches!(t, ContentToken::Op { operator, .. } if operator == b"f"))
.count();
assert_eq!(
fills, 2,
"expected two selection highlights for Red+Blue, got {fills}"
);
}
#[test]
fn ch_non_ch_field_returns_none() {
let mut pdf = Pdf::open(Cursor::new(build_btn_widget_pdf())).expect("parse");
let result = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(
result.unwrap().is_none(),
"Btn field must return None from Ch generator"
);
}
#[test]
fn ch_degenerate_rect_returns_none() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Ch /T (f) /Rect [10 10 10 30]>>\nendobj\n");
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0));
assert!(result.is_ok());
assert!(
result.unwrap().is_none(),
"degenerate rect should return None"
);
}
#[test]
fn ch_combo_v_renders_as_tj() {
let ff_combo = 0x20000_i64; let raw = build_combo_pdf("Blue", ff_combo);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("generate");
let xobj_ref = result.expect("combo must produce appearance");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream");
};
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
let Object::Dictionary(ap_dict) = wdict.get("AP").expect("AP").clone() else {
panic!("AP not dict")
};
assert!(
matches!(ap_dict.get("N"), Some(Object::Reference(_))),
"/AP/N must be a reference for combo"
);
let mut found = false;
for tok in ContentStreamParser::new(&stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"Blue" {
found = true;
}
}
}
}
assert!(found, "combo Tj must contain value 'Blue'");
}
#[test]
fn ch_combo_no_value_blank_appearance() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Ch /T (c) \
/Ff 131072 /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("generate");
assert!(
result.is_some(),
"combo without /V must still produce blank appearance"
);
}
#[test]
fn ch_list_selected_index_highlighted() {
let raw = build_list_pdf("(Red) (Green) (Blue)", "[1]", "");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("generate");
let xobj_ref = result.expect("list must produce appearance");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream");
};
let content_str = String::from_utf8_lossy(&stream.data);
let mut tj_vals: Vec<Vec<u8>> = Vec::new();
for tok in ContentStreamParser::new(&stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
tj_vals.push(s.clone());
}
}
}
assert!(
tj_vals.contains(&b"Red".to_vec()),
"Red must appear in Tj; got: {tj_vals:?}"
);
assert!(
tj_vals.contains(&b"Green".to_vec()),
"Green must appear in Tj"
);
assert!(
tj_vals.contains(&b"Blue".to_vec()),
"Blue must appear in Tj"
);
assert!(
content_str.contains("rg")
&& content_str.contains("re\n")
&& content_str.contains("f\n"),
"selected row must have highlight (rg re f), got:\n{content_str}"
);
let bt_pos = content_str.find("BT").expect("BT missing");
let rg_pos = content_str.find("rg").expect("rg missing");
assert!(
rg_pos < bt_pos,
"highlight (rg) must appear before BT; rg@{rg_pos}, BT@{bt_pos}"
);
}
#[test]
fn ch_list_multi_select_highlights() {
let raw = build_list_pdf("(Red) (Green) (Blue)", "[0 2]", "");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream")
};
let content_str = String::from_utf8_lossy(&stream.data);
let f_count = content_str.lines().filter(|l| l.trim() == "f").count();
assert_eq!(f_count, 2, "two selected rows → two 'f' ops; got {f_count}");
}
#[test]
fn ch_list_v_selection_matches_opt_export() {
let raw = build_list_pdf("(Red) (Green) (Blue)", "", "(Green)");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream")
};
let content_str = String::from_utf8_lossy(&stream.data);
let f_count = content_str.lines().filter(|l| l.trim() == "f").count();
assert_eq!(f_count, 1, "single /V match → one highlight; got {f_count}");
let bt_pos = content_str.find("BT").expect("BT missing");
let rg_pos = content_str.find("rg");
if let Some(rg) = rg_pos {
assert!(rg < bt_pos, "highlight before BT");
}
}
#[test]
fn ch_list_opt_export_display_pair() {
let raw = build_list_pdf("[(expA)(dispA)] [(expB)(dispB)]", "[0]", "");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream")
};
let mut tj_vals: Vec<Vec<u8>> = Vec::new();
for tok in ContentStreamParser::new(&stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
tj_vals.push(s.clone());
}
}
}
assert!(
tj_vals.contains(&b"dispA".to_vec()),
"display string 'dispA' must appear in Tj; got {tj_vals:?}"
);
assert!(
tj_vals.contains(&b"dispB".to_vec()),
"display string 'dispB' must appear in Tj"
);
assert!(
!tj_vals.contains(&b"expA".to_vec()),
"export string must not appear in Tj"
);
}
#[test]
fn ch_combo_opt_display_substitution() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Ch /T (c2) \
/Ff 131072 /V (expX) /Opt [[(expX)(DisplayX)] [(expY)(DisplayY)]] \
/DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = 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 \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let Object::Stream(stream) = pdf.resolve(xobj_ref).expect("resolve xobj") else {
panic!("not stream")
};
let mut found_display = false;
for tok in ContentStreamParser::new(&stream.data).flatten() {
let ContentToken::Op { operands, operator } = tok else {
continue;
};
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"DisplayX" {
found_display = true;
}
}
}
}
assert!(
found_display,
"combo must render display string 'DisplayX' from /Opt"
);
}
#[test]
fn ch_list_round_trip() {
let raw = build_list_pdf("(Red) (Green) (Blue)", "[1]", "");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let xobj_ref = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("must produce appearance");
let mut out = Vec::new();
write_pdf(&mut pdf, &mut out).expect("write_pdf");
let mut pdf2 = Pdf::open(Cursor::new(out)).expect("re-parse");
let widget_obj = pdf2.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let Object::Dictionary(wdict) = widget_obj else {
panic!("not dict")
};
assert!(wdict.get("AP").is_some(), "/AP missing after round-trip");
let xobj2 = pdf2.resolve(xobj_ref).expect("re-resolve xobj");
assert!(
matches!(xobj2, Object::Stream(_)),
"xobj must be stream after round-trip"
);
}
#[test]
fn btn_no_rect_returns_none() {
let pdf = build_btn_pdf_obj4("<</Type /Annot /Subtype /Widget /FT /Btn /T (c)>>");
let mut pdf = Pdf::open(Cursor::new(pdf)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(result.is_none(), "missing /Rect must return None");
}
#[test]
fn btn_pushbutton_indirect_mk_ca() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n(OK)\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (pb) \
/Ff 65536 /MK <</CA 5 0 R>> /Rect [10 10 80 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"pushbutton with indirect /MK/CA must produce appearance"
);
}
#[test]
fn btn_pushbutton_no_mk_ca_empty_caption() {
let pdf = build_btn_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Btn /T (pb2) \
/Ff 65536 /MK <<>> /Rect [10 10 80 30]>>",
);
let mut pdf = Pdf::open(Cursor::new(pdf)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"pushbutton with empty /MK must produce appearance"
);
}
#[test]
fn btn_as_indirect_reference() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n/Checked\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk_as_ind) \
/AS 5 0 R /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error")
.expect("must produce appearance");
let widget_obj = pdf.resolve(ObjectRef::new(4, 0)).expect("resolve widget");
let wdict = widget_obj.into_dict().expect("widget dict");
let ap = wdict.get("AP").expect("/AP").clone();
let ap_dict = ap.into_dict().expect("/AP dict");
let n_dict_obj = ap_dict.get("N").expect("/AP/N").clone();
let n_dict = n_dict_obj.into_dict().expect("/AP/N dict");
assert!(
n_dict.get(b"Checked".as_ref()).is_some(),
"/AP/N must have 'Checked' from indirect /AS"
);
}
#[test]
fn btn_checkbox_indirect_mk_ca() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n(8)\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (chk_ind_ca) \
/MK <</CA 5 0 R>> /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let on_ref = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error")
.expect("must produce appearance");
let on_obj = pdf.resolve(on_ref).expect("resolve on");
assert!(
matches!(on_obj, Object::Stream(_)),
"on-state must be a stream"
);
}
#[test]
fn btn_checkbox_empty_ca_uses_default_glyph() {
let pdf = build_btn_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Btn /T (c_empty_ca) \
/MK <</CA ()>> /Rect [10 10 30 30]>>",
);
let (_ap_n, content) = btn_on_state_content(pdf);
let mut found_default = false;
for tok in ContentStreamParser::new(&content).flatten() {
if let ContentToken::Op { operands, operator } = tok {
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"4" {
found_default = true;
}
}
}
}
}
assert!(
found_default,
"empty /MK/CA must fall back to default glyph '4'"
);
}
#[test]
fn btn_checkbox_utf16be_out_of_range_uses_default_glyph() {
let pdf = build_btn_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Btn /T (c_utf16_oor) \
/MK <</CA <FEFF0100>>> /Rect [10 10 30 30]>>",
);
let (_ap_n, content) = btn_on_state_content(pdf);
let mut found_default = false;
for tok in ContentStreamParser::new(&content).flatten() {
if let ContentToken::Op { operands, operator } = tok {
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
if s == b"4" {
found_default = true;
}
}
}
}
}
assert!(
found_default,
"out-of-range UTF-16BE char must fall back to default glyph '4'"
);
}
#[test]
fn install_state_appearances_widget_not_dict() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(b"4 0 obj\n42\nendobj\n");
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = install_state_appearances(
&mut pdf,
ObjectRef::new(4, 0),
b"Yes",
b"on_content".to_vec(),
b"q Q\n".to_vec(),
20.0,
20.0,
);
assert!(
result.is_err(),
"non-dict widget must return Err from install_state_appearances"
);
}
#[test]
fn install_normal_appearance_widget_not_dict() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(b"4 0 obj\n99\nendobj\n");
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = install_normal_appearance(
&mut pdf,
ObjectRef::new(4, 0),
b"q Q".to_vec(),
100.0,
20.0,
None,
);
assert!(
result.is_err(),
"non-dict widget must return Err from install_normal_appearance"
);
}
#[test]
fn install_normal_appearance_ap_indirect_reference() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n<<>>\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V (hello) /Rect [10 10 200 30] \
/AP 5 0 R>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = install_normal_appearance(
&mut pdf,
ObjectRef::new(4, 0),
b"q Q".to_vec(),
190.0,
20.0,
None,
);
assert!(
result.is_ok(),
"indirect /AP must be handled without error: {:?}",
result
);
}
#[test]
fn resolve_inherited_name_null_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\nnull\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT 5 0 R /T (f) \
/Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(result.is_none(), "Null /FT must return None");
}
#[test]
fn resolve_inherited_integer_null_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\nnull\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (c_null_ff) \
/Ff 5 0 R /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"Null /Ff must fall back to 0 (checkbox) and produce appearance"
);
}
#[test]
fn resolve_inherited_integer_non_integer_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n/BadType\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (c_bad_ff) \
/Ff 5 0 R /Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"non-integer /Ff must fall back to 0 and produce appearance"
);
}
#[test]
fn resolve_da_null_da_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\nnull\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA 5 0 R /V (hello) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"Null /DA must not prevent appearance generation"
);
}
#[test]
fn resolve_da_non_string_da_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n42\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f2) \
/DA 5 0 R /V (world) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"non-string /DA must not prevent appearance generation"
);
}
#[test]
fn resolve_da_acroform_da_indirect_ref() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n(/Helv 12 Tf 0 g)\nendobj\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R \
/AcroForm <</Fields [4 0 R] /DA 5 0 R>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_ind_da) \
/V (test) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"indirect AcroForm /DA must produce appearance"
);
}
#[test]
fn resolve_da_acroform_indirect_ref() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n<</Fields [4 0 R] /DA (/Helv 12 Tf 0 g)>>\nendobj\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm 5 0 R>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_acro_ind) \
/V (hello) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"indirect /AcroForm must produce appearance via indirect /DA"
);
}
#[test]
fn resolve_rect_indirect_to_non_array() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n42\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Btn /T (c_bad_rect) \
/Rect 5 0 R>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_none(),
"indirect /Rect → non-array must return None"
);
}
#[test]
fn resolve_rect_array_with_non_numeric_element() {
let pdf = build_btn_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Btn /T (c_bad_rect_elem) \
/Rect [10 10 /Bad 30]>>",
);
let mut pdf = Pdf::open(Cursor::new(pdf)).expect("parse");
let result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_none(),
"/Rect with non-numeric element must return None"
);
}
#[test]
fn tx_indirect_v_non_string_returns_none() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n123\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V 5 0 R /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_none(),
"indirect /V → non-String must return None"
);
}
#[test]
fn tx_v_is_integer_returns_none() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V 42 /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(result.is_none(), "integer /V must return None");
}
#[test]
fn tx_degenerate_small_rect_returns_none() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f) \
/DA (/Helv 12 Tf 0 g) /V (test) /Rect [10 10 10.5 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_none(),
"degenerate (narrow) /Rect must return None"
);
}
#[test]
fn lookup_dr_basefont_basefont_indirect_ref() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off6 = raw.len() as u64;
raw.extend_from_slice(b"6 0 obj\n/Helvetica\nendobj\n");
let off5 = raw.len() as u64;
raw.extend_from_slice(
b"5 0 obj\n<</Type /Font /Subtype /Type1 /BaseFont 6 0 R>>\nendobj\n",
);
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R \
/AcroForm <</Fields [4 0 R] /DR <</Font <</Helv 5 0 R>>>> \
/DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_ind_bf) \
/V (test) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 7\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 7 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"indirect /BaseFont must be resolved and produce appearance"
);
}
#[test]
fn resolve_inherited_name_non_name_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n(NotAName)\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT 5 0 R /T (f) \
/Rect [10 10 30 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let btn_result = generate_button_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
btn_result.is_none(),
"non-Name /FT must return None from Btn generator"
);
}
#[test]
fn resolve_inherited_object_null_value() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(b"1 0 obj\n<</Type /Catalog /Pages 2 0 R>>\nendobj\n");
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\nnull\nendobj\n");
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_null_v) \
/DA (/Helv 12 Tf 0 g) /V 5 0 R /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(result.is_none(), "Null /V must return None");
}
#[test]
fn resolve_da_parent_is_not_dict() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off5 = raw.len() as u64;
raw.extend_from_slice(b"5 0 obj\n99\nendobj\n"); let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R \
/AcroForm <</Fields [4 0 R] /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /T (f_ndict_parent) \
/Parent 5 0 R>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let da = resolve_da(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
da.is_some(),
"non-dict /Parent must fall back to AcroForm /DA"
);
}
#[test]
fn lookup_dr_basefont_no_font_in_dr() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R \
/AcroForm <</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_no_dr_font) \
/V (test) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"missing /DR /Font must fall back to default font"
);
}
#[test]
fn lookup_dr_basefont_from_indirect_acroform_dr() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off5 = raw.len() as u64;
raw.extend_from_slice(
b"5 0 obj\n<</Fields [4 0 R] /DR <</Font <</Helv \
<</Type /Font /Subtype /Type1 /BaseFont /Helvetica \
/Encoding /WinAnsiEncoding>>>>>> /DA (/Helv 12 Tf 0 g)>>\nendobj\n",
);
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm 5 0 R>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_ind_acro_dr) \
/V (test) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 6\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
{off5:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 6 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"indirect AcroForm /DR must yield appearance"
);
}
#[test]
fn lookup_dr_basefont_standard_font_matched() {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R \
/AcroForm <</Fields [4 0 R] \
/DR <</Font <</TimesR <</Type /Font /Subtype /Type1 /BaseFont /Times-Roman>>>>>> \
/DA (/TimesR 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (f_times) \
/V (test) /Rect [10 10 200 30]>>\nendobj\n",
);
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result =
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0)).expect("must not error");
assert!(
result.is_some(),
"Times-Roman /BaseFont in /DR must produce appearance"
);
}
fn build_ch_pdf_obj4(obj4_body: &str) -> Vec<u8> {
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(format!("4 0 obj\n{obj4_body}\nendobj\n").as_bytes());
let xref_start = raw.len() as u64;
let xref = format!(
"xref\n0 5\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n"
);
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size 5 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
fn build_ch_pdf_with_extras(obj4_body: &str, extra_objs: &[&str]) -> Vec<u8> {
let n = 5 + extra_objs.len();
let mut raw = Vec::<u8>::new();
raw.extend_from_slice(b"%PDF-1.4\n");
let off1 = raw.len() as u64;
raw.extend_from_slice(
b"1 0 obj\n<</Type /Catalog /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = raw.len() as u64;
raw.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = raw.len() as u64;
raw.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R]>>\nendobj\n",
);
let off4 = raw.len() as u64;
raw.extend_from_slice(format!("4 0 obj\n{obj4_body}\nendobj\n").as_bytes());
let mut extra_offsets = Vec::new();
for body in extra_objs {
extra_offsets.push(raw.len() as u64);
let idx = extra_offsets.len() + 4; raw.extend_from_slice(format!("{idx} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = raw.len() as u64;
let mut xref = format!("xref\n0 {n}\n0000000000 65535 f \n");
for off in [off1, off2, off3, off4].iter().chain(extra_offsets.iter()) {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
raw.extend_from_slice(xref.as_bytes());
raw.extend_from_slice(
format!("trailer\n<</Size {n} /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
raw
}
fn ch_ap_content(pdf: &mut Pdf<Cursor<Vec<u8>>>, widget: ObjectRef) -> Vec<u8> {
let xobj_ref = generate_choice_field_appearance(pdf, widget)
.expect("generate")
.expect("must produce appearance");
match pdf.resolve(xobj_ref).expect("resolve xobj") {
Object::Stream(s) => s.data,
other => panic!("xobj must be a stream, got {other:?}"),
}
}
fn tj_strings_from(content: &[u8]) -> Vec<Vec<u8>> {
let mut out = Vec::new();
for tok in ContentStreamParser::new(content).flatten() {
if let ContentToken::Op { operands, operator } = tok {
if operator == b"Tj" {
if let Some(Object::String(s)) = operands.first() {
out.push(s.clone());
}
}
}
}
out
}
fn count_fills(content: &[u8]) -> usize {
ContentStreamParser::new(content)
.flatten()
.filter(|t| matches!(t, ContentToken::Op { operator, .. } if operator == b"f"))
.count()
}
#[test]
fn ch_no_rect_returns_none() {
let raw =
build_ch_pdf_obj4("<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 /V (A)>>");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(result.is_none(), "missing /Rect must return None");
}
#[test]
fn ch_combo_non_standard_da_font() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (Hello) /DA (/F1 10 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Hello".to_vec()),
"value must appear in Tj; got {tjs:?}"
);
}
#[test]
fn ch_combo_v_indirect_string() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V 5 0 R /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["(Indirect)"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Indirect".to_vec()),
"indirect /V string must appear in Tj; got {tjs:?}"
);
}
#[test]
fn ch_combo_v_indirect_non_string() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V 5 0 R /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["42"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"combo must still produce appearance for non-string indirect /V"
);
}
#[test]
fn ch_combo_v_direct_non_string() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V /SomeName /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"combo must still produce appearance for non-string /V"
);
}
#[test]
fn ch_combo_auto_size() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (Auto) /DA (/Helv 0 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Auto".to_vec()),
"auto-size combo must render value; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_element_indirect_array() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (expA) /Opt [5 0 R] /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["[(expA)(dispA)]"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"dispA".to_vec()),
"indirect /Opt pair: display must be rendered; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_indirect_array() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (A) /Opt 5 0 R /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["[(A)(A) (B)(B) (C)(C)]"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"A".to_vec()),
"indirect /Opt array must be resolved; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_indirect_non_array() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (Hello) /Opt 5 0 R /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["42"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Hello".to_vec()),
"combo must render /V when /Opt non-array; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_pair_elements_indirect_strings() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (expB) /Opt [[5 0 R 6 0 R]] /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["(expB)", "(dispB)"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"dispB".to_vec()),
"indirect pair string elements must be resolved; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_pair_element_indirect_non_string() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (X) /Opt [[5 0 R (dispZ)]] /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
&["99"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"X".to_vec()),
"non-string export ref: /V must be rendered as-is; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_flat_string_match() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (B) /Opt [(A) (B) (C)] /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"B".to_vec()),
"flat /Opt match: /V must be rendered; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_flat_string_no_match() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (Z) /Opt [(A) (B) (C)] /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Z".to_vec()),
"flat /Opt no-match: /V must be rendered as-is; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_element_neither_string_nor_array() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (expX) /Opt [99 [(expX)(dispX)]] /DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"dispX".to_vec()),
"invalid /Opt element skipped; valid pair must still match; got {tjs:?}"
);
}
#[test]
fn ch_list_opt_element_indirect_string() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [5 0 R 6 0 R 7 0 R] /I [1] \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
&["(Red)", "(Green)", "(Blue)"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Red".to_vec())
&& tjs.contains(&b"Green".to_vec())
&& tjs.contains(&b"Blue".to_vec()),
"indirect /Opt elements must be rendered; got {tjs:?}"
);
}
#[test]
fn ch_list_opt_element_invalid_type() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [42 (Valid)] /I [0] \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Valid".to_vec()),
"valid /Opt entry must still render; got {tjs:?}"
);
}
#[test]
fn ch_list_i_element_indirect_integer() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /I [5 0 R] \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
&["1"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
assert_eq!(
count_fills(&content),
1,
"indirect /I integer must select one row"
);
}
#[test]
fn ch_list_i_negative_and_out_of_bounds_indices() {
let raw = build_list_pdf("(Red) (Green) (Blue)", "[-1 99 1]", "");
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
assert_eq!(
count_fills(&content),
1,
"negative and out-of-bounds /I indices must be ignored"
);
}
#[test]
fn ch_list_v_array_with_indirect_string_elem() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /V [(Red) 5 0 R] \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
&["(Blue)"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
assert_eq!(
count_fills(&content),
2,
"indirect string elem in /V array must select two rows"
);
}
#[test]
fn ch_list_v_non_string_non_array() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /V /SomeName \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
assert_eq!(
count_fills(&content),
0,
"/V as Name must produce no selection highlight"
);
}
#[test]
fn ch_list_ti_indirect_integer() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /TI 5 0 R /I [1] \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
&["1"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Green".to_vec()),
"indirect /TI must offset display; got {tjs:?}"
);
assert!(
!tjs.contains(&b"Red".to_vec()),
"Red must be scrolled off by /TI=1; got {tjs:?}"
);
}
#[test]
fn ch_list_ti_indirect_out_of_bounds() {
let raw = build_ch_pdf_with_extras(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /TI 5 0 R \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
&["999"],
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Red".to_vec()),
"out-of-bounds indirect /TI must default to 0 (show all); got {tjs:?}"
);
}
#[test]
fn ch_list_ti_direct_integer() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green) (Blue)] /TI 2 \
/DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Blue".to_vec()),
"/TI 2 must show only Blue; got {tjs:?}"
);
assert!(
!tjs.contains(&b"Red".to_vec()),
"Red must be scrolled off by /TI=2; got {tjs:?}"
);
}
#[test]
fn ch_list_auto_size() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(Red) (Green)] /I [0] \
/DA (/Helv 0 Tf 0 g) /Rect [100 600 300 700]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"Red".to_vec()),
"auto-size list must render options; got {tjs:?}"
);
}
#[test]
fn ch_list_rows_clip_below_bbox() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(A) (B) (C) (D) (E) (F) (G) (H) (I) (J)] /I [0] \
/DA (/Helv 12 Tf 0 g) /Rect [100 700 300 730]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
!tjs.is_empty(),
"at least first option must be rendered before clipping"
);
assert!(
tjs.len() < 10,
"some rows must be clipped; got {}",
tjs.len()
);
}
#[test]
fn ch_list_ti_with_clip() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [(A) (B) (C) (D) (E) (F) (G) (H)] /TI 5 /I [5 6] \
/DA (/Helv 12 Tf 0 g) /Rect [100 700 300 730]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"F".to_vec()),
"/TI=5 must show option F; got {tjs:?}"
);
}
#[test]
fn ch_list_empty_opt() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (list) /Ff 0 \
/Opt [] /DA (/Helv 10 Tf 0 g) /Rect [100 600 300 700]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let result = generate_choice_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("must not error");
assert!(
result.is_some(),
"list with empty /Opt must still produce appearance"
);
}
#[test]
fn ch_combo_opt_pair_export_direct_integer() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (fallback) /Opt [[99 (disp99)]] \
/DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"fallback".to_vec()),
"non-string export in pair → /V rendered unchanged; got {tjs:?}"
);
}
#[test]
fn ch_combo_opt_pair_export_matches_v_returns_display() {
let raw = build_ch_pdf_obj4(
"<</Type /Annot /Subtype /Widget /FT /Ch /T (c) /Ff 131072 \
/V (matchKey) /Opt [[(matchKey)(ShowThis)] [(other)(Other)]] \
/DA (/Helv 12 Tf 0 g) /Rect [100 700 300 720]>>",
);
let mut pdf = Pdf::open(Cursor::new(raw)).expect("parse");
let content = ch_ap_content(&mut pdf, ObjectRef::new(4, 0));
let tjs = tj_strings_from(&content);
assert!(
tjs.contains(&b"ShowThis".to_vec()),
"matching export key must return display string; got {tjs:?}"
);
}
fn build_ap_holder_chain_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (field1) \
/V (Hello World) /Rect [100 700 300 720] /P 3 0 R /AP 6 0 R>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n7 0 R\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\n<</D 99 0 R>>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 8\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
0000000000 00000 f \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 8 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn ap_holder_chain_preserves_existing_entries() {
let mut pdf = Pdf::open(Cursor::new(build_ap_holder_chain_pdf())).expect("parse");
generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Tx field handled");
let widget = pdf.resolve(ObjectRef::new(4, 0)).expect("widget");
let widget = widget.as_dict().expect("widget is a dict");
let ap = widget
.get("AP")
.and_then(Object::as_dict)
.expect("/AP is a direct dict after generation");
assert!(ap.get("N").is_some(), "/AP/N must be installed");
assert_eq!(
ap.get("D"),
Some(&Object::Reference(ObjectRef::new(99, 0))),
"pre-existing /AP/D must survive: holder chain to the /AP dict was dropped"
);
}
fn build_acroform_holder_chain_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm 6 0 R>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (field1) \
/V (Hi) /Rect [100 700 300 720] /P 3 0 R>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n7 0 R\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(
b"7 0 obj\n<</Fields [4 0 R] /DR <<>> /DA (/Helv 12 Tf 1 0 0 rg)>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 8\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
0000000000 00000 f \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 8 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn acroform_holder_chain_resolves_default_da() {
let mut pdf = Pdf::open(Cursor::new(build_acroform_holder_chain_pdf())).expect("parse");
let xobj_ref = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Tx field handled");
let xobj = pdf.resolve(xobj_ref).expect("resolve xobj");
let stream = xobj.as_stream().expect("xobj is a stream");
let content = String::from_utf8_lossy(&stream.data).into_owned();
assert!(
content.contains("1 0 0 rg"),
"AcroForm /DA red colour must reach the stream via the holder chain; got:\n{content}"
);
}
fn build_dr_holder_chain_pdf() -> Vec<u8> {
let mut pdf: Vec<u8> = 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 /Pages 2 0 R /AcroForm \
<</Fields [4 0 R] /DR 6 0 R /DA (/F1 12 Tf 0 g)>>>>\nendobj\n",
);
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<</Type /Pages /Kids [3 0 R] /Count 1>>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<</Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [4 0 R]>>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(
b"4 0 obj\n<</Type /Annot /Subtype /Widget /FT /Tx /T (field1) \
/V (Hi) /Rect [100 700 300 720] /P 3 0 R>>\nendobj\n",
);
let off5 = pdf.len() as u64;
pdf.extend_from_slice(b"6 0 obj\n7 0 R\nendobj\n");
let off6 = pdf.len() as u64;
pdf.extend_from_slice(b"7 0 obj\n<</Font <</F1 8 0 R>>>>\nendobj\n");
let off7 = pdf.len() as u64;
pdf.extend_from_slice(
b"8 0 obj\n<</Type /Font /Subtype /Type1 /BaseFont /Times-Roman>>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 9\n\
0000000000 65535 f \n\
{off1:010} 00000 n \n\
{off2:010} 00000 n \n\
{off3:010} 00000 n \n\
{off4:010} 00000 n \n\
0000000000 00000 f \n\
{off5:010} 00000 n \n\
{off6:010} 00000 n \n\
{off7:010} 00000 n \n",
);
pdf.extend_from_slice(xref.as_bytes());
let trailer = format!("trailer\n<</Size 9 /Root 1 0 R>>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn dr_holder_chain_resolves_font_basefont() {
let mut pdf = Pdf::open(Cursor::new(build_dr_holder_chain_pdf())).expect("parse");
let xobj_ref = generate_text_field_appearance(&mut pdf, ObjectRef::new(4, 0))
.expect("generate")
.expect("Tx field handled");
let xobj = pdf.resolve(xobj_ref).expect("resolve xobj");
let stream = xobj.as_stream().expect("xobj is a stream");
let res = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("/Resources is a dict");
let fonts = res
.get("Font")
.and_then(Object::as_dict)
.expect("/Resources/Font is a dict");
let f1 = fonts.get("F1").expect("F1 entry");
let fdict = resolve_ref_chain(&mut pdf, f1)
.expect("resolve F1")
.0
.into_dict()
.expect("F1 resolves to a font dict");
assert_eq!(
fdict.get("BaseFont"),
Some(&Object::Name(b"Times-Roman".to_vec())),
"BaseFont must resolve from the /DR holder chain to Times-Roman"
);
}
}