use super::check::find_first_object_ref;
use crate::filters::decode_stream_data;
use crate::{Object, ObjectRef, Pdf};
use std::fmt;
use std::io::Cursor;
#[derive(Debug)]
pub enum ShowLinearizationError {
Malformed { message: String },
Io(Box<dyn std::error::Error + Send + Sync>),
}
impl fmt::Display for ShowLinearizationError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ShowLinearizationError::Malformed { message } => {
write!(f, "malformed linearization data: {message}")
}
ShowLinearizationError::Io(e) => write!(f, "I/O error: {e}"),
}
}
}
impl std::error::Error for ShowLinearizationError {}
impl From<crate::Error> for ShowLinearizationError {
fn from(e: crate::Error) -> Self {
ShowLinearizationError::Io(Box::new(e))
}
}
impl From<std::io::Error> for ShowLinearizationError {
fn from(e: std::io::Error) -> Self {
ShowLinearizationError::Io(Box::new(e))
}
}
type ShowResult<T> = std::result::Result<T, ShowLinearizationError>;
macro_rules! malformed {
($($arg:tt)*) => {
ShowLinearizationError::Malformed { message: format!($($arg)*) }
};
}
struct BitReader<'a> {
buf: &'a [u8],
byte_pos: usize,
bit_pos: u32,
}
impl<'a> BitReader<'a> {
fn new(buf: &'a [u8]) -> Self {
Self {
buf,
byte_pos: 0,
bit_pos: 0,
}
}
fn get_bits(&mut self, bits: u32) -> ShowResult<u64> {
if bits == 0 {
return Ok(0);
}
if bits > 64 {
return Err(malformed!(
"hint stream requests {bits}-bit field (exceeds 64-bit limit)"
));
}
let mut result: u64 = 0;
let mut remaining = bits;
while remaining > 0 {
if self.byte_pos >= self.buf.len() {
return Err(malformed!(
"hint stream truncated: ran out of bits while reading a {bits}-bit field"
));
}
let avail = 8 - self.bit_pos;
let take = remaining.min(avail);
let cur = (self.buf[self.byte_pos] as u64) & ((1u64 << avail) - 1);
let shift = avail - take;
let chunk = cur >> shift;
result = (result << take) | chunk;
self.bit_pos += take;
if self.bit_pos == 8 {
self.bit_pos = 0;
self.byte_pos += 1;
}
remaining -= take;
}
Ok(result)
}
fn get_bits_u32(&mut self, bits: u32) -> ShowResult<u32> {
let v = self.get_bits(bits)?;
u32::try_from(v).map_err(|_| malformed!("hint stream field {v} does not fit in u32"))
}
fn skip_to_next_byte(&mut self) {
if self.bit_pos != 0 {
self.bit_pos = 0;
self.byte_pos += 1;
}
}
}
struct LinParameters {
file_size: u64,
first_page_object: u64,
first_page_end: u64,
npages: u32,
xref_zero_offset: u64,
first_page: i64,
h_offset: u64,
h_length: u64,
}
impl LinParameters {
fn adjusted_offset(&self, offset: u64) -> u64 {
if offset >= self.h_offset {
offset.wrapping_add(self.h_length)
} else {
offset
}
}
}
struct HPageOffset {
min_nobjects: u32,
first_page_offset: u64,
nbits_delta_nobjects: u32,
min_page_length: u64,
nbits_delta_page_length: u32,
min_content_offset: u64,
nbits_delta_content_offset: u32,
min_content_length: u64,
nbits_delta_content_length: u32,
nbits_nshared_objects: u32,
nbits_shared_identifier: u32,
nbits_shared_numerator: u32,
shared_denominator: u32,
entries: Vec<HPageOffsetEntry>,
}
struct HPageOffsetEntry {
delta_nobjects: u64,
delta_page_length: u64,
nshared_objects: u32,
shared_identifiers: Vec<u64>,
shared_numerators: Vec<u64>,
delta_content_offset: u64,
delta_content_length: u64,
}
struct HSharedObject {
first_shared_obj: u64,
first_shared_offset: u64,
nshared_first_page: u32,
nshared_total: u32,
nbits_nobjects: u32,
min_group_length: u64,
nbits_delta_group_length: u32,
entries: Vec<HSharedObjectEntry>,
}
struct HSharedObjectEntry {
delta_group_length: u64,
signature_present: bool,
nobjects_minus_one: u64,
}
struct HGeneric {
first_object: u64,
first_object_offset: u64,
nobjects: u32,
group_length: u64,
}
fn read_h_page_offset(buf: &[u8], npages: u32) -> ShowResult<HPageOffset> {
let mut h = BitReader::new(buf);
let min_nobjects = h.get_bits_u32(32)?;
let first_page_offset = h.get_bits(32)?;
let nbits_delta_nobjects = h.get_bits_u32(16)?;
let min_page_length = h.get_bits(32)?;
let nbits_delta_page_length = h.get_bits_u32(16)?;
let min_content_offset = h.get_bits(32)?;
let nbits_delta_content_offset = h.get_bits_u32(16)?;
let min_content_length = h.get_bits(32)?;
let nbits_delta_content_length = h.get_bits_u32(16)?;
let nbits_nshared_objects = h.get_bits_u32(16)?;
let nbits_shared_identifier = h.get_bits_u32(16)?;
let nbits_shared_numerator = h.get_bits_u32(16)?;
let shared_denominator = h.get_bits_u32(16)?;
let n = npages as usize;
let mut entries: Vec<HPageOffsetEntry> = (0..n)
.map(|_| HPageOffsetEntry {
delta_nobjects: 0,
delta_page_length: 0,
nshared_objects: 0,
shared_identifiers: Vec::new(),
shared_numerators: Vec::new(),
delta_content_offset: 0,
delta_content_length: 0,
})
.collect();
for e in entries.iter_mut() {
e.delta_nobjects = h.get_bits(nbits_delta_nobjects)?;
}
h.skip_to_next_byte();
for e in entries.iter_mut() {
e.delta_page_length = h.get_bits(nbits_delta_page_length)?;
}
h.skip_to_next_byte();
for e in entries.iter_mut() {
e.nshared_objects = h.get_bits_u32(nbits_nshared_objects)?;
}
h.skip_to_next_byte();
let remaining_bits = (h.buf.len() - h.byte_pos)
.saturating_mul(8)
.saturating_sub(h.bit_pos as usize);
let total_shared: u64 = entries.iter().map(|e| e.nshared_objects as u64).sum();
if total_shared > remaining_bits as u64 {
return Err(malformed!(
"page offset hint table claims {total_shared} shared-object refs but only {remaining_bits} bits remain"
));
}
for e in entries.iter_mut() {
for _ in 0..e.nshared_objects {
e.shared_identifiers
.push(h.get_bits(nbits_shared_identifier)?);
}
}
h.skip_to_next_byte();
for e in entries.iter_mut() {
for _ in 0..e.nshared_objects {
e.shared_numerators
.push(h.get_bits(nbits_shared_numerator)?);
}
}
h.skip_to_next_byte();
for e in entries.iter_mut() {
e.delta_content_offset = h.get_bits(nbits_delta_content_offset)?;
}
h.skip_to_next_byte();
for e in entries.iter_mut() {
e.delta_content_length = h.get_bits(nbits_delta_content_length)?;
}
h.skip_to_next_byte();
Ok(HPageOffset {
min_nobjects,
first_page_offset,
nbits_delta_nobjects,
min_page_length,
nbits_delta_page_length,
min_content_offset,
nbits_delta_content_offset,
min_content_length,
nbits_delta_content_length,
nbits_nshared_objects,
nbits_shared_identifier,
nbits_shared_numerator,
shared_denominator,
entries,
})
}
fn read_h_shared_object(buf: &[u8]) -> ShowResult<HSharedObject> {
let mut h = BitReader::new(buf);
let first_shared_obj = h.get_bits(32)?;
let first_shared_offset = h.get_bits(32)?;
let nshared_first_page = h.get_bits_u32(32)?;
let nshared_total = h.get_bits_u32(32)?;
let nbits_nobjects = h.get_bits_u32(16)?;
let min_group_length = h.get_bits(32)?;
let nbits_delta_group_length = h.get_bits_u32(16)?;
let remaining_bits = (h.buf.len() - h.byte_pos)
.saturating_mul(8)
.saturating_sub(h.bit_pos as usize);
if nshared_total as usize > remaining_bits {
return Err(malformed!(
"shared-object hint table claims {nshared_total} entries but only {remaining_bits} bits remain"
));
}
let n = nshared_total as usize;
let mut entries: Vec<HSharedObjectEntry> = (0..n)
.map(|_| HSharedObjectEntry {
delta_group_length: 0,
signature_present: false,
nobjects_minus_one: 0,
})
.collect();
for e in entries.iter_mut() {
e.delta_group_length = h.get_bits(nbits_delta_group_length)?;
}
h.skip_to_next_byte();
for e in entries.iter_mut() {
e.signature_present = h.get_bits(1)? != 0;
}
h.skip_to_next_byte();
for e in entries.iter() {
if e.signature_present {
for _ in 0..4 {
let _ = h.get_bits(32)?;
}
}
}
for e in entries.iter_mut() {
e.nobjects_minus_one = h.get_bits(nbits_nobjects)?;
}
h.skip_to_next_byte();
Ok(HSharedObject {
first_shared_obj,
first_shared_offset,
nshared_first_page,
nshared_total,
nbits_nobjects,
min_group_length,
nbits_delta_group_length,
entries,
})
}
fn read_h_generic(buf: &[u8]) -> ShowResult<HGeneric> {
let mut h = BitReader::new(buf);
let first_object = h.get_bits(32)?;
let first_object_offset = h.get_bits(32)?;
let nobjects = h.get_bits_u32(32)?;
let group_length = h.get_bits(32)?;
Ok(HGeneric {
first_object,
first_object_offset,
nobjects,
group_length,
})
}
fn dump_page_offset(out: &mut String, p: &LinParameters, t: &HPageOffset) {
use std::fmt::Write;
let _ = write!(
out,
"min_nobjects: {}\n\
first_page_offset: {}\n\
nbits_delta_nobjects: {}\n\
min_page_length: {}\n\
nbits_delta_page_length: {}\n\
min_content_offset: {}\n\
nbits_delta_content_offset: {}\n\
min_content_length: {}\n\
nbits_delta_content_length: {}\n\
nbits_nshared_objects: {}\n\
nbits_shared_identifier: {}\n\
nbits_shared_numerator: {}\n\
shared_denominator: {}\n",
t.min_nobjects,
p.adjusted_offset(t.first_page_offset),
t.nbits_delta_nobjects,
t.min_page_length,
t.nbits_delta_page_length,
t.min_content_offset,
t.nbits_delta_content_offset,
t.min_content_length,
t.nbits_delta_content_length,
t.nbits_nshared_objects,
t.nbits_shared_identifier,
t.nbits_shared_numerator,
t.shared_denominator,
);
for (i, pe) in t.entries.iter().enumerate() {
let _ = write!(
out,
"Page {i}:\n \
nobjects: {}\n \
length: {}\n \
content_offset: {}\n \
content_length: {}\n \
nshared_objects: {}\n",
pe.delta_nobjects.wrapping_add(t.min_nobjects as u64),
pe.delta_page_length.wrapping_add(t.min_page_length),
pe.delta_content_offset.wrapping_add(t.min_content_offset),
pe.delta_content_length.wrapping_add(t.min_content_length),
pe.nshared_objects,
);
for j in 0..pe.nshared_objects as usize {
let _ = writeln!(out, " identifier {j}: {}", pe.shared_identifiers[j]);
let _ = writeln!(out, " numerator {j}: {}", pe.shared_numerators[j]);
}
}
}
fn dump_shared_object(out: &mut String, p: &LinParameters, t: &HSharedObject) {
use std::fmt::Write;
let _ = write!(
out,
"first_shared_obj: {}\n\
first_shared_offset: {}\n\
nshared_first_page: {}\n\
nshared_total: {}\n\
nbits_nobjects: {}\n\
min_group_length: {}\n\
nbits_delta_group_length: {}\n",
t.first_shared_obj,
p.adjusted_offset(t.first_shared_offset),
t.nshared_first_page,
t.nshared_total,
t.nbits_nobjects,
t.min_group_length,
t.nbits_delta_group_length,
);
for (i, se) in t.entries.iter().enumerate() {
let _ = write!(
out,
"Shared Object {i}:\n group length: {}\n",
se.delta_group_length.wrapping_add(t.min_group_length)
);
if se.signature_present {
out.push_str(" signature present\n");
}
if se.nobjects_minus_one != 0 {
let _ = writeln!(out, " nobjects: {}", se.nobjects_minus_one.wrapping_add(1));
}
}
}
fn dump_generic(out: &mut String, p: &LinParameters, t: &HGeneric) {
use std::fmt::Write;
let _ = write!(
out,
"first_object: {}\n\
first_object_offset: {}\n\
nobjects: {}\n\
group_length: {}\n",
t.first_object,
p.adjusted_offset(t.first_object_offset),
t.nobjects,
t.group_length,
);
}
fn param_u64(dict: &crate::Dictionary, key: &'static str) -> ShowResult<u64> {
match dict.get(key) {
Some(Object::Integer(n)) if *n >= 0 => Ok(*n as u64),
Some(Object::Real(r)) if r.is_finite() && *r >= 0.0 && r.fract() == 0.0 => Ok(*r as u64),
_ => Err(malformed!(
"/{key} is missing or not a non-negative integer in the linearization dictionary"
)),
}
}
fn is_linearized(dict: &crate::Dictionary, file_size: u64) -> bool {
let linearized_ok = match dict.get("Linearized") {
Some(Object::Integer(n)) => *n == 1,
Some(Object::Real(r)) => r.is_finite() && r.floor() == 1.0,
_ => false,
};
if !linearized_ok {
return false;
}
if let Some(Object::Integer(l)) = dict.get("L") {
if *l < 0 || (*l as u64) != file_size {
return false;
}
}
true
}
fn read_lin_parameters(dict: &crate::Dictionary, file_size: u64) -> ShowResult<LinParameters> {
let first_page_object = param_u64(dict, "O")?;
let first_page_end = param_u64(dict, "E")?;
let npages_u64 = param_u64(dict, "N")?;
let npages = u32::try_from(npages_u64)
.map_err(|_| malformed!("/N ({npages_u64}) does not fit in u32"))?;
let xref_zero_offset = param_u64(dict, "T")?;
let first_page: i64 = match dict.get("P") {
Some(Object::Integer(n)) => *n,
Some(Object::Null) | None => 0,
_ => return Err(malformed!("/P is present but not an integer")),
};
let (h_offset, h_length) = match dict.get("H") {
Some(Object::Array(arr)) if arr.len() >= 2 => {
let off = match &arr[0] {
Object::Integer(n) if *n >= 0 => *n as u64,
_ => return Err(malformed!("/H[0] is not a non-negative integer")),
};
let len = match &arr[1] {
Object::Integer(n) if *n >= 0 => *n as u64,
_ => return Err(malformed!("/H[1] is not a non-negative integer")),
};
(off, len)
}
_ => return Err(malformed!("/H is missing or not an [offset length] array")),
};
Ok(LinParameters {
file_size,
first_page_object,
first_page_end,
npages,
xref_zero_offset,
first_page,
h_offset,
h_length,
})
}
fn read_hint_offsets(hint_dict: &crate::Dictionary) -> ShowResult<(usize, Option<usize>)> {
let s_offset = match hint_dict.get("S") {
Some(Object::Integer(n)) if *n >= 0 => usize::try_from(*n)
.map_err(|_| malformed!("hint stream /S offset does not fit in platform usize"))?,
_ => return Err(malformed!("hint stream /S offset is missing or invalid")),
};
let outline_offset: Option<usize> = match hint_dict.get("O") {
Some(Object::Integer(n)) if *n >= 0 => Some(
usize::try_from(*n)
.map_err(|_| malformed!("hint stream /O offset does not fit in platform usize"))?,
),
Some(Object::Integer(_)) => return Err(malformed!("hint stream /O offset is negative")),
_ => None,
};
Ok((s_offset, outline_offset))
}
fn show_with_pdf(
pdf: &mut Pdf<Cursor<Vec<u8>>>,
file_bytes: &[u8],
display_name: &str,
) -> ShowResult<String> {
let file_size = file_bytes.len() as u64;
let not_linearized = || Ok(format!("{display_name} is not linearized\n"));
let Some(first_obj_ref) = find_first_object_ref(file_bytes) else {
return not_linearized();
};
let first_obj = pdf.resolve_borrowed(first_obj_ref)?;
let Some(param_dict) = first_obj.as_dict().cloned() else {
return not_linearized();
};
if !is_linearized(¶m_dict, file_size) {
return not_linearized();
}
let params = read_lin_parameters(¶m_dict, file_size)?;
let page_count = crate::pages::page_refs(pdf)?.len();
if params.npages as usize != page_count {
return Err(malformed!(
"/N ({}) does not match the document page count ({page_count})",
params.npages
));
}
let h_usize = usize::try_from(params.h_offset)
.map_err(|_| malformed!("/H[0] does not fit in platform usize"))?;
if h_usize >= file_bytes.len() {
return Err(malformed!(
"/H[0] offset ({}) is beyond file length ({file_size})",
params.h_offset
));
}
let Some(hint_ref) = parse_obj_header(&file_bytes[h_usize..]) else {
return Err(malformed!(
"/H[0] offset ({}) does not point at an object header",
params.h_offset
));
};
let hint_obj = pdf.resolve_borrowed(hint_ref)?;
let Object::Stream(stream) = &hint_obj else {
return Err(malformed!(
"hint stream object at /H[0] offset {} is not a stream",
params.h_offset
));
};
let decompressed = decode_stream_data(&stream.dict, &stream.data)
.map_err(|e| malformed!("hint stream could not be decoded: {e}"))?;
let (s_offset, outline_offset) = read_hint_offsets(&stream.dict)?;
if s_offset >= decompressed.len() {
return Err(malformed!(
"hint stream /S offset ({s_offset}) is out of bounds (hint size {})",
decompressed.len()
));
}
let page_offset = read_h_page_offset(&decompressed, params.npages)?;
let shared_object = read_h_shared_object(&decompressed[s_offset..])?;
let outline = match outline_offset {
Some(off) => {
if off >= decompressed.len() {
return Err(malformed!(
"hint stream /O offset ({off}) is out of bounds (hint size {})",
decompressed.len()
));
}
Some(read_h_generic(&decompressed[off..])?)
}
None => None,
};
Ok(format_dump(
display_name,
¶ms,
&page_offset,
&shared_object,
outline.as_ref(),
))
}
fn format_dump(
display_name: &str,
p: &LinParameters,
page_offset: &HPageOffset,
shared_object: &HSharedObject,
outline: Option<&HGeneric>,
) -> String {
use std::fmt::Write;
let mut out = String::new();
let _ = write!(out, "{display_name}: linearization data:\n\n");
let _ = write!(
out,
"file_size: {}\n\
first_page_object: {}\n\
first_page_end: {}\n\
npages: {}\n\
xref_zero_offset: {}\n\
first_page: {}\n\
H_offset: {}\n\
H_length: {}\n\n",
p.file_size,
p.first_page_object,
p.first_page_end,
p.npages,
p.xref_zero_offset,
p.first_page,
p.h_offset,
p.h_length,
);
out.push_str("Page Offsets Hint Table\n\n");
dump_page_offset(&mut out, p, page_offset);
out.push_str("\nShared Objects Hint Table\n\n");
dump_shared_object(&mut out, p, shared_object);
if let Some(g) = outline {
if g.nobjects > 0 {
out.push_str("\nOutlines Hint Table\n\n");
dump_generic(&mut out, p, g);
}
}
out
}
fn parse_obj_header(window: &[u8]) -> Option<ObjectRef> {
fn is_ws(b: u8) -> bool {
matches!(b, b'\0' | b'\t' | b'\n' | b'\x0c' | b'\r' | b' ')
}
let mut i = 0;
while i < window.len() && is_ws(window[i]) {
i += 1;
}
let num_start = i;
while i < window.len() && window[i].is_ascii_digit() {
i += 1;
}
if i == num_start {
return None;
}
let num: u32 = std::str::from_utf8(&window[num_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_ws(window[i]) {
return None;
}
while i < window.len() && is_ws(window[i]) {
i += 1;
}
let gen_start = i;
while i < window.len() && window[i].is_ascii_digit() {
i += 1;
}
if i == gen_start {
return None;
}
let gen: u16 = std::str::from_utf8(&window[gen_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_ws(window[i]) {
return None;
}
while i < window.len() && is_ws(window[i]) {
i += 1;
}
if window.get(i..i + 3) != Some(b"obj") {
return None;
}
Some(ObjectRef::new(num, gen))
}
pub fn show_linearization_bytes(
file_bytes: &[u8],
display_name: &str,
) -> std::result::Result<String, ShowLinearizationError> {
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec()))
.map_err(|e| ShowLinearizationError::Io(Box::new(e)))?;
show_with_pdf(&mut pdf, file_bytes, display_name)
}
pub fn show_linearization_path(
path: &std::path::Path,
) -> std::result::Result<String, ShowLinearizationError> {
let file_bytes = std::fs::read(path)?;
let mut pdf = Pdf::open(Cursor::new(file_bytes.clone()))
.map_err(|e| ShowLinearizationError::Io(Box::new(e)))?;
let display_name = path.to_string_lossy();
show_with_pdf(&mut pdf, &file_bytes, &display_name)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::hint_stream::{encode_hint_stream, HintStreamBuilder};
#[test]
fn bitreader_reads_back_msb_first_patterns() {
let mut b = HintStreamBuilder::new();
b.write_bits(0xDEAD_BEEF, 32);
b.write_bits(0b101, 3);
b.write_bits(0b10110, 5);
b.write_bits(0b1100_1010_0011, 12);
let buf = b.finish();
let mut r = BitReader::new(&buf);
assert_eq!(r.get_bits(32).unwrap(), 0xDEAD_BEEF);
assert_eq!(r.get_bits(3).unwrap(), 0b101);
assert_eq!(r.get_bits(5).unwrap(), 0b10110);
assert_eq!(r.get_bits(12).unwrap(), 0b1100_1010_0011);
}
#[test]
fn bitreader_zero_bits_is_noop() {
let buf = [0xABu8];
let mut r = BitReader::new(&buf);
assert_eq!(r.get_bits(0).unwrap(), 0);
assert_eq!(r.get_bits(8).unwrap(), 0xAB);
}
#[test]
fn bitreader_skip_to_next_byte_matches_align() {
let mut b = HintStreamBuilder::new();
b.write_bits(1, 1);
b.align_to_byte();
b.write_bits(0x5A, 8);
let buf = b.finish();
let mut r = BitReader::new(&buf);
assert_eq!(r.get_bits(1).unwrap(), 1);
r.skip_to_next_byte();
assert_eq!(r.get_bits(8).unwrap(), 0x5A);
}
#[test]
fn bitreader_skip_on_boundary_is_noop() {
let mut b = HintStreamBuilder::new();
b.write_bits(0xAB, 8);
b.write_bits(0xCD, 8);
let buf = b.finish();
let mut r = BitReader::new(&buf);
assert_eq!(r.get_bits(8).unwrap(), 0xAB);
r.skip_to_next_byte(); assert_eq!(r.get_bits(8).unwrap(), 0xCD);
}
#[test]
fn bitreader_truncated_errors() {
let buf = [0xFFu8];
let mut r = BitReader::new(&buf);
assert!(r.get_bits(16).is_err(), "reading past end must error");
}
#[test]
fn bitreader_rejects_more_than_64_bits() {
let buf = [0u8; 16];
let mut r = BitReader::new(&buf);
assert!(r.get_bits(65).is_err());
}
#[test]
fn bitreader_get_bits_u32_rejects_oversized_value() {
let buf = [0xFFu8; 5];
let mut r = BitReader::new(&buf);
assert!(r.get_bits_u32(40).is_err());
}
use crate::linearization::hint_page::{
bits_needed, PageOffsetEntry, PageOffsetHeader, PageOffsetHintTable,
};
use crate::linearization::hint_shared::{
SharedGroupEntry, SharedObjectEntry, SharedObjectHeader, SharedObjectHintTable,
};
fn rich_page_offset_table() -> PageOffsetHintTable {
let header = PageOffsetHeader {
least_object_count: 2,
location_of_first_page: 1000,
bits_object_count_delta: 2,
least_page_length: 50,
bits_page_length_delta: 8,
least_content_offset: 4,
bits_content_offset_delta: 4,
least_content_length: 50,
bits_content_length_delta: 8,
bits_shared_object_count: 2,
bits_shared_object_id: 3,
bits_numerator: 2,
denominator: 4,
};
let entries = vec![
PageOffsetEntry {
object_count_minus_least: 0,
page_length_minus_least: 0,
shared_object_count: 0,
shared_object_ids: vec![],
shared_object_numerators: vec![],
content_stream_offset: 0,
content_stream_length: 0,
},
PageOffsetEntry {
object_count_minus_least: 3,
page_length_minus_least: 130,
shared_object_count: 2,
shared_object_ids: vec![5, 1],
shared_object_numerators: vec![3, 0],
content_stream_offset: 9,
content_stream_length: 130,
},
PageOffsetEntry {
object_count_minus_least: 1,
page_length_minus_least: 7,
shared_object_count: 1,
shared_object_ids: vec![4],
shared_object_numerators: vec![2],
content_stream_offset: 3,
content_stream_length: 7,
},
];
PageOffsetHintTable { header, entries }
}
fn rich_shared_object_table() -> SharedObjectHintTable {
let header = SharedObjectHeader {
first_object_number: 17,
location: 2000,
first_page_entries: 2,
section_entries: 3,
bits_group_object_count: 0,
least_length: 33,
bits_length_delta: 8,
};
let groups = vec![SharedGroupEntry { object_count: 1 }; 3];
let objects = vec![
SharedObjectEntry {
length_minus_least: 0,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
SharedObjectEntry {
length_minus_least: 157,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
SharedObjectEntry {
length_minus_least: 75,
signature_present: false,
signature: None,
nobjects_minus_one: 0,
},
];
SharedObjectHintTable {
header,
groups,
objects,
}
}
#[test]
fn round_trip_page_offset_table() {
let po = rich_page_offset_table();
let so = rich_shared_object_table();
let encoded = encode_hint_stream(&po, &so, None).expect("encode");
let decoded = read_h_page_offset(&encoded.uncompressed, po.entries.len() as u32)
.expect("decode page offset");
assert_eq!(decoded.min_nobjects, po.header.least_object_count);
assert_eq!(decoded.first_page_offset, po.header.location_of_first_page);
assert_eq!(
decoded.nbits_delta_nobjects,
po.header.bits_object_count_delta
);
assert_eq!(decoded.min_page_length, po.header.least_page_length);
assert_eq!(
decoded.nbits_delta_page_length,
po.header.bits_page_length_delta
);
assert_eq!(decoded.min_content_offset, po.header.least_content_offset);
assert_eq!(
decoded.nbits_delta_content_offset,
po.header.bits_content_offset_delta
);
assert_eq!(decoded.min_content_length, po.header.least_content_length);
assert_eq!(
decoded.nbits_delta_content_length,
po.header.bits_content_length_delta
);
assert_eq!(
decoded.nbits_nshared_objects,
po.header.bits_shared_object_count
);
assert_eq!(
decoded.nbits_shared_identifier,
po.header.bits_shared_object_id
);
assert_eq!(decoded.nbits_shared_numerator, po.header.bits_numerator);
assert_eq!(decoded.shared_denominator, po.header.denominator);
assert_eq!(decoded.entries.len(), po.entries.len());
for (d, o) in decoded.entries.iter().zip(po.entries.iter()) {
assert_eq!(d.delta_nobjects, o.object_count_minus_least as u64);
assert_eq!(d.delta_page_length, o.page_length_minus_least);
assert_eq!(d.nshared_objects, o.shared_object_count);
assert_eq!(
d.shared_identifiers,
o.shared_object_ids
.iter()
.map(|&x| x as u64)
.collect::<Vec<_>>()
);
assert_eq!(
d.shared_numerators,
o.shared_object_numerators
.iter()
.map(|&x| x as u64)
.collect::<Vec<_>>()
);
assert_eq!(d.delta_content_offset, o.content_stream_offset);
assert_eq!(d.delta_content_length, o.content_stream_length);
}
}
#[test]
fn round_trip_shared_object_table() {
let po = rich_page_offset_table();
let so = rich_shared_object_table();
let encoded = encode_hint_stream(&po, &so, None).expect("encode");
let decoded = read_h_shared_object(
&encoded.uncompressed[encoded.shared_section_offset_in_uncompressed..],
)
.expect("decode shared object");
assert_eq!(
decoded.first_shared_obj,
so.header.first_object_number as u64
);
assert_eq!(decoded.first_shared_offset, so.header.location);
assert_eq!(decoded.nshared_first_page, so.header.first_page_entries);
assert_eq!(decoded.nshared_total, so.header.section_entries);
assert_eq!(decoded.nbits_nobjects, so.header.bits_group_object_count);
assert_eq!(decoded.min_group_length, so.header.least_length);
assert_eq!(
decoded.nbits_delta_group_length,
so.header.bits_length_delta
);
assert_eq!(decoded.entries.len(), so.objects.len());
for (d, o) in decoded.entries.iter().zip(so.objects.iter()) {
assert_eq!(d.delta_group_length, o.length_minus_least as u64);
assert_eq!(d.signature_present, o.signature_present);
assert_eq!(d.nobjects_minus_one, o.nobjects_minus_one as u64);
}
}
#[test]
fn round_trip_uses_nonzero_bit_widths() {
let po = rich_page_offset_table();
assert!(po.header.bits_page_length_delta >= 8);
assert_eq!(bits_needed(130), 8);
}
#[test]
fn adjusted_offset_adds_h_length_at_or_above_h_offset() {
let p = LinParameters {
file_size: 0,
first_page_object: 0,
first_page_end: 0,
npages: 0,
xref_zero_offset: 0,
first_page: 0,
h_offset: 100,
h_length: 50,
};
assert_eq!(p.adjusted_offset(99), 99); assert_eq!(p.adjusted_offset(100), 150); assert_eq!(p.adjusted_offset(200), 250); }
#[test]
fn outlines_section_emitted_only_when_nobjects_positive() {
let p = LinParameters {
file_size: 10,
first_page_object: 1,
first_page_end: 5,
npages: 1,
xref_zero_offset: 8,
first_page: 0,
h_offset: 100,
h_length: 50,
};
let po = HPageOffset {
min_nobjects: 1,
first_page_offset: 0,
nbits_delta_nobjects: 0,
min_page_length: 0,
nbits_delta_page_length: 0,
min_content_offset: 0,
nbits_delta_content_offset: 0,
min_content_length: 0,
nbits_delta_content_length: 0,
nbits_nshared_objects: 0,
nbits_shared_identifier: 0,
nbits_shared_numerator: 0,
shared_denominator: 4,
entries: vec![HPageOffsetEntry {
delta_nobjects: 0,
delta_page_length: 0,
nshared_objects: 0,
shared_identifiers: vec![],
shared_numerators: vec![],
delta_content_offset: 0,
delta_content_length: 0,
}],
};
let so = HSharedObject {
first_shared_obj: 0,
first_shared_offset: 0,
nshared_first_page: 0,
nshared_total: 0,
nbits_nobjects: 0,
min_group_length: 0,
nbits_delta_group_length: 0,
entries: vec![],
};
let empty_outline = HGeneric {
first_object: 0,
first_object_offset: 0,
nobjects: 0,
group_length: 0,
};
let dump_no_outline = format_dump("f.pdf", &p, &po, &so, Some(&empty_outline));
assert!(!dump_no_outline.contains("Outlines Hint Table"));
let outline = HGeneric {
first_object: 30,
first_object_offset: 120, nobjects: 2,
group_length: 99,
};
let dump_outline = format_dump("f.pdf", &p, &po, &so, Some(&outline));
assert!(dump_outline.contains("\nOutlines Hint Table\n\n"));
assert!(dump_outline.contains("first_object: 30\n"));
assert!(dump_outline.contains("first_object_offset: 170\n"));
assert!(dump_outline.contains("nobjects: 2\n"));
assert!(dump_outline.contains("group_length: 99\n"));
}
#[test]
fn shared_object_conditional_lines() {
let p = LinParameters {
file_size: 0,
first_page_object: 0,
first_page_end: 0,
npages: 0,
xref_zero_offset: 0,
first_page: 0,
h_offset: 0,
h_length: 0,
};
let t = HSharedObject {
first_shared_obj: 0,
first_shared_offset: 0,
nshared_first_page: 2,
nshared_total: 2,
nbits_nobjects: 1,
min_group_length: 10,
nbits_delta_group_length: 0,
entries: vec![
HSharedObjectEntry {
delta_group_length: 0,
signature_present: true,
nobjects_minus_one: 2,
},
HSharedObjectEntry {
delta_group_length: 5,
signature_present: false,
nobjects_minus_one: 0,
},
],
};
let mut out = String::new();
dump_shared_object(&mut out, &p, &t);
assert!(out.contains(
"Shared Object 0:\n group length: 10\n signature present\n nobjects: 3\n"
));
assert!(out.contains("Shared Object 1:\n group length: 15\n"));
assert!(!out.contains("Shared Object 1:\n group length: 15\n signature present"));
}
#[test]
fn shared_object_signature_present_skips_128_bits() {
let nbits_delta_group_length = 4u32;
let nbits_nobjects = 4u32;
let nshared_total = 2u32;
let mut b = HintStreamBuilder::new();
b.write_bits(1, 32); b.write_bits(0, 32); b.write_bits(2, 32); b.write_bits(nshared_total as u64, 32); b.write_bits(nbits_nobjects as u64, 16); b.write_bits(0, 32); b.write_bits(nbits_delta_group_length as u64, 16); b.write_bits(3, nbits_delta_group_length);
b.write_bits(9, nbits_delta_group_length);
b.align_to_byte();
b.write_bits(1, 1);
b.write_bits(0, 1);
b.align_to_byte();
for _ in 0..4 {
b.write_bits(0xDEAD_BEEF, 32);
}
b.write_bits(5, nbits_nobjects);
b.write_bits(7, nbits_nobjects);
b.align_to_byte();
let buf = b.finish();
let decoded = read_h_shared_object(&buf).expect("decode");
assert!(decoded.entries[0].signature_present);
assert_eq!(decoded.entries[0].delta_group_length, 3);
assert_eq!(decoded.entries[0].nobjects_minus_one, 5);
assert!(!decoded.entries[1].signature_present);
assert_eq!(decoded.entries[1].delta_group_length, 9);
assert_eq!(decoded.entries[1].nobjects_minus_one, 7);
}
#[test]
fn shared_object_oversized_nshared_total_is_malformed() {
let mut b = HintStreamBuilder::new();
b.write_bits(0, 32); b.write_bits(0, 32); b.write_bits(0, 32); b.write_bits(1_000_000, 32); b.write_bits(0, 16); b.write_bits(0, 32); b.write_bits(0, 16); let buf = b.finish();
assert_eq!(buf.len(), 24, "header is exactly 24 bytes, no column data");
let is_malformed = matches!(
read_h_shared_object(&buf),
Err(ShowLinearizationError::Malformed { .. })
);
assert!(
is_malformed,
"expected Malformed for oversized nshared_total"
);
}
#[test]
fn page_offset_oversized_nshared_objects_is_malformed() {
let mut b = HintStreamBuilder::new();
b.write_bits(0, 32); b.write_bits(0, 32); b.write_bits(0, 16); b.write_bits(0, 32); b.write_bits(0, 16); b.write_bits(0, 32); b.write_bits(0, 16); b.write_bits(0, 32); b.write_bits(0, 16); b.write_bits(32, 16); b.write_bits(0, 16); b.write_bits(0, 16); b.write_bits(1, 16); b.write_bits(1_000_000, 32);
b.align_to_byte();
let buf = b.finish();
assert_eq!(
buf.len(),
40,
"36-byte header + 4-byte nshared_objects column"
);
let is_malformed = matches!(
read_h_page_offset(&buf, 1),
Err(ShowLinearizationError::Malformed { .. })
);
assert!(
is_malformed,
"expected Malformed for oversized per-page nshared_objects"
);
}
fn non_linearized_pdf() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn show_bytes_reports_non_linearized_as_ok_line() {
let pdf = non_linearized_pdf();
let out = show_linearization_bytes(&pdf, "x.pdf").expect("not-linearized is Ok");
assert_eq!(out, "x.pdf is not linearized\n");
}
#[test]
fn show_bytes_first_object_not_a_dict_is_not_linearized() {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n42\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Catalog /Pages 3 0 R >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Pages /Kids [4 0 R] /Count 1 >>\nendobj\n");
let off4 = pdf.len();
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
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"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 2 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let out = show_linearization_bytes(&pdf, "intfirst.pdf").expect("not-linearized is Ok");
assert_eq!(out, "intfirst.pdf is not linearized\n");
}
#[test]
fn param_u64_rejects_fractional() {
let mut d = crate::Dictionary::new();
d.insert("N", Object::Real(1.5));
assert!(matches!(
param_u64(&d, "N"),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn parse_obj_header_basic() {
assert_eq!(
parse_obj_header(b"7 0 obj\n<<>>"),
Some(ObjectRef::new(7, 0))
);
assert_eq!(parse_obj_header(b"not an obj"), None);
}
#[test]
fn read_h_generic_decodes_four_fields() {
let mut b = HintStreamBuilder::new();
b.write_bits(11, 32); b.write_bits(222, 32); b.write_bits(3, 32); b.write_bits(4444, 32); let buf = b.finish();
let g = read_h_generic(&buf).expect("decode generic");
assert_eq!(g.first_object, 11);
assert_eq!(g.first_object_offset, 222);
assert_eq!(g.nobjects, 3);
assert_eq!(g.group_length, 4444);
}
#[test]
fn read_h_generic_truncated_errors() {
assert!(read_h_generic(&[0u8; 4]).is_err());
}
#[test]
fn error_display_and_from_conversions() {
let m = ShowLinearizationError::Malformed {
message: "boom".into(),
};
assert_eq!(format!("{m}"), "malformed linearization data: boom");
let io: ShowLinearizationError = std::io::Error::other("disk gone").into();
assert!(matches!(io, ShowLinearizationError::Io(_)));
assert!(format!("{io}").starts_with("I/O error: "));
let core: ShowLinearizationError = crate::Error::Missing("X").into();
assert!(matches!(core, ShowLinearizationError::Io(_)));
}
use crate::linearization::plan::LinearizationPlan;
use crate::linearization::renumber::RenumberMap;
use crate::linearization::writer::write_linearized;
use crate::writer::WriteOptions;
use crate::Pdf;
use std::io::Cursor;
fn tiny_source() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n\
{off3:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn linearized_bytes() -> Vec<u8> {
let raw = tiny_source();
let mut pdf = Pdf::open(Cursor::new(raw.clone())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf, false).unwrap();
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = Pdf::open(Cursor::new(raw)).unwrap();
let mut doc =
write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default()).unwrap();
doc.back_patch().unwrap();
doc.bytes
}
#[test]
fn show_linearized_happy_path_produces_dump() {
let bytes = linearized_bytes();
let out = show_linearization_bytes(&bytes, "lin.pdf").expect("dump");
assert!(out.starts_with("lin.pdf: linearization data:\n\n"));
assert!(out.contains("\nPage Offsets Hint Table\n\n"));
assert!(out.contains("\nShared Objects Hint Table\n\n"));
assert!(out.contains("Page 0:\n"));
assert!(!out.contains("Page 1:\n"));
}
#[test]
fn show_linearization_path_round_trips_via_tempfile() {
let bytes = linearized_bytes();
let dir = std::env::temp_dir();
let path = dir.join(format!("flpdf-show-test-{}.pdf", std::process::id()));
std::fs::write(&path, &bytes).unwrap();
let out = show_linearization_path(&path).expect("path dump");
let _ = std::fs::remove_file(&path);
assert!(out.contains(": linearization data:\n\n"));
assert!(out.contains(&*path.to_string_lossy()));
}
#[test]
fn show_linearization_path_missing_file_is_io_error() {
let path = std::path::Path::new("/nonexistent/flpdf/definitely/missing.pdf");
assert!(matches!(
show_linearization_path(path),
Err(ShowLinearizationError::Io(_))
));
}
#[test]
fn bad_l_value_is_not_linearized() {
let mut bytes = linearized_bytes();
let pos = bytes.windows(3).position(|w| w == b"/L ").expect("/L");
let dstart = pos + 3;
let dend = dstart
+ bytes[dstart..]
.iter()
.position(|&b| !b.is_ascii_digit())
.unwrap();
let last = dend - 1;
bytes[last] ^= 1;
let out = show_linearization_bytes(&bytes, "badL.pdf").expect("not-linearized is Ok");
assert_eq!(out, "badL.pdf is not linearized\n");
}
#[test]
fn missing_required_key_is_malformed() {
let mut bytes = linearized_bytes();
let pos = bytes.windows(3).position(|w| w == b"/N ").expect("/N");
bytes[pos + 1] = b'Z';
let result = show_linearization_bytes(&bytes, "noN.pdf");
assert!(matches!(
result,
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn decode_failure_is_malformed() {
let mut bytes = linearized_bytes();
let s_pos = bytes.windows(3).position(|w| w == b"/S ").expect("hint /S");
let stream_kw = bytes[s_pos..]
.windows(7)
.position(|w| w == b"stream\n")
.map(|p| s_pos + p + 7)
.expect("stream keyword after hint dict");
bytes[stream_kw + 4] ^= 0xFF;
let result = show_linearization_bytes(&bytes, "badhint.pdf");
assert!(
matches!(result, Err(ShowLinearizationError::Malformed { .. })),
"corrupt hint payload must yield Malformed, got {result:?}"
);
}
fn full_param_dict() -> crate::Dictionary {
let mut d = crate::Dictionary::new();
d.insert("O", Object::Integer(8));
d.insert("E", Object::Integer(1212));
d.insert("N", Object::Integer(2));
d.insert("T", Object::Integer(1885));
d.insert(
"H",
Object::Array(vec![Object::Integer(601), Object::Integer(128)]),
);
d
}
#[test]
fn read_lin_parameters_happy() {
let mut d = full_param_dict();
d.insert("P", Object::Integer(0));
let p = read_lin_parameters(&d, 2103).unwrap();
assert_eq!(p.file_size, 2103);
assert_eq!(p.first_page_object, 8);
assert_eq!(p.first_page_end, 1212);
assert_eq!(p.npages, 2);
assert_eq!(p.xref_zero_offset, 1885);
assert_eq!(p.first_page, 0);
assert_eq!(p.h_offset, 601);
assert_eq!(p.h_length, 128);
}
#[test]
fn read_lin_parameters_default_first_page_when_p_absent() {
let p = read_lin_parameters(&full_param_dict(), 2103).unwrap();
assert_eq!(p.first_page, 0, "/P absent defaults to 0");
}
#[test]
fn read_lin_parameters_p_wrong_type_is_malformed() {
let mut d = full_param_dict();
d.insert("P", Object::Name(b"oops".to_vec()));
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h_too_short_is_malformed() {
let mut d = full_param_dict();
d.insert("H", Object::Array(vec![Object::Integer(601)]));
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h_not_array_is_malformed() {
let mut d = full_param_dict();
d.insert("H", Object::Integer(5));
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h0_wrong_type_is_malformed() {
let mut d = full_param_dict();
d.insert(
"H",
Object::Array(vec![Object::Name(b"x".to_vec()), Object::Integer(128)]),
);
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_lin_parameters_h1_wrong_type_is_malformed() {
let mut d = full_param_dict();
d.insert(
"H",
Object::Array(vec![Object::Integer(601), Object::Name(b"x".to_vec())]),
);
assert!(matches!(
read_lin_parameters(&d, 2103),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_hint_offsets_happy_and_outline() {
let mut d = crate::Dictionary::new();
d.insert("S", Object::Integer(36));
d.insert("O", Object::Integer(72));
assert_eq!(read_hint_offsets(&d).unwrap(), (36, Some(72)));
let mut d2 = crate::Dictionary::new();
d2.insert("S", Object::Integer(36));
assert_eq!(read_hint_offsets(&d2).unwrap(), (36, None));
}
#[test]
fn read_hint_offsets_missing_s_is_malformed() {
let d = crate::Dictionary::new();
assert!(matches!(
read_hint_offsets(&d),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn read_hint_offsets_negative_outline_is_malformed() {
let mut d = crate::Dictionary::new();
d.insert("S", Object::Integer(36));
d.insert("O", Object::Integer(-1));
assert!(matches!(
read_hint_offsets(&d),
Err(ShowLinearizationError::Malformed { .. })
));
}
#[test]
fn parse_obj_header_negative_branches() {
assert_eq!(parse_obj_header(b""), None); assert_eq!(parse_obj_header(b"7"), None); assert_eq!(parse_obj_header(b"7 "), None); assert_eq!(parse_obj_header(b"7 0"), None); assert_eq!(parse_obj_header(b"7 0 "), None); assert_eq!(parse_obj_header(b"7 0 xyz"), None); assert_eq!(parse_obj_header(b"7 x obj"), None); assert_eq!(parse_obj_header(b" 7 0 obj"), Some(ObjectRef::new(7, 0)));
}
#[test]
fn is_linearized_accepts_integer_and_real_one() {
let mut d = crate::Dictionary::new();
d.insert("Linearized", Object::Integer(1));
assert!(is_linearized(&d, 100));
let mut d2 = crate::Dictionary::new();
d2.insert("Linearized", Object::Real(1.0));
assert!(is_linearized(&d2, 100));
}
#[test]
fn is_linearized_rejects_missing_or_wrong_linearized() {
assert!(!is_linearized(&crate::Dictionary::new(), 100));
let mut d = crate::Dictionary::new();
d.insert("Linearized", Object::Integer(0));
assert!(!is_linearized(&d, 100));
}
#[test]
fn is_linearized_rejects_l_mismatch() {
let mut d = crate::Dictionary::new();
d.insert("Linearized", Object::Integer(1));
d.insert("L", Object::Integer(999)); assert!(!is_linearized(&d, 100));
d.insert("L", Object::Integer(100));
assert!(is_linearized(&d, 100));
}
#[test]
fn show_bytes_dict_without_linearized_is_not_linearized() {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n\
{off3:010} 00000 n \n"
);
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
let out = show_linearization_bytes(&pdf, "plain.pdf").expect("not-linearized is Ok");
assert_eq!(out, "plain.pdf is not linearized\n");
}
}