use crate::filters::{decode_stream_data_with_limits, is_decode_output_limit_error, DecodeLimits};
use crate::{Diagnostic, Diagnostics, Dictionary, Error, Object, Pdf, PdfOpenOptions};
use std::io::{Read, Seek};
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct CheckReport {
pub valid: bool,
pub diagnostics: Diagnostics,
pub summary: Option<CheckSummary>,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct CheckSummary {
pub version: String,
pub encrypted: bool,
pub linearized: bool,
pub extension_level: Option<i64>,
}
pub fn check_reader<R: Read + Seek>(reader: R) -> crate::Result<CheckReport> {
check_reader_inner(reader, true)
}
pub fn check_reader_with_options<R: Read + Seek>(
reader: R,
options: PdfOpenOptions,
) -> crate::Result<CheckReport> {
check_reader_inner_with_options(reader, options, DecodeLimits::default())
}
pub fn check_reader_with_options_and_limits<R: Read + Seek>(
reader: R,
options: PdfOpenOptions,
limits: DecodeLimits,
) -> crate::Result<CheckReport> {
check_reader_inner_with_options(reader, options, limits)
}
pub fn check_reader_strict<R: Read + Seek>(reader: R) -> crate::Result<CheckReport> {
check_reader_inner(reader, false)
}
fn check_reader_inner<R: Read + Seek>(reader: R, allow_repair: bool) -> crate::Result<CheckReport> {
check_reader_inner_with_options(
reader,
PdfOpenOptions {
repair: allow_repair,
..PdfOpenOptions::default()
},
DecodeLimits::default(),
)
}
fn check_reader_inner_with_options<R: Read + Seek>(
reader: R,
options: PdfOpenOptions,
limits: DecodeLimits,
) -> crate::Result<CheckReport> {
let allow_repair = options.repair;
let mut pdf = if allow_repair {
match Pdf::open_with_options(reader, options) {
Ok(pdf) => pdf,
Err(error @ Error::Encrypted(_)) => return Err(error),
Err(error) => {
let mut diagnostics = Diagnostics::default();
diagnostics.push(Diagnostic::error(error.to_string(), None));
return Ok(CheckReport {
valid: false,
diagnostics,
summary: None,
});
}
}
} else {
Pdf::open_with_options(reader, options)?
};
let mut diagnostics = pdf.repair_diagnostics().clone();
if pdf.uses_weak_crypto() {
diagnostics.push(Diagnostic::warning(
"encrypted PDF uses weak crypto; processing continued",
None,
));
}
if pdf.trailer().get_ref("Root").is_none() {
diagnostics.push(Diagnostic::error("trailer is missing /Root", None));
}
let linearized = match is_linearized_pdf(&mut pdf) {
Ok(value) => value,
Err(error) => {
diagnostics.push(Diagnostic::warning(
format!("failed to inspect linearization hint: {error}"),
None,
));
false
}
};
if linearized {
diagnostics.push(Diagnostic::warning(
"linearized PDF detected: rewrite support preserves hint object but does not recompute linearization tables",
None,
));
}
check_content_streams(&mut pdf, &mut diagnostics, limits);
let summary = CheckSummary {
version: pdf.version().to_string(),
encrypted: pdf.is_encrypted(),
linearized,
extension_level: pdf.adobe_extension_level(),
};
Ok(CheckReport {
valid: !diagnostics.has_errors(),
diagnostics,
summary: Some(summary),
})
}
fn is_linearized_pdf<R: Read + Seek>(reader: &mut Pdf<R>) -> crate::Result<bool> {
reader.linearized_hint_ref().map(|hint| hint.is_some())
}
const GENERALIZED_FILTERS: [&[u8]; 5] = [
b"FlateDecode",
b"LZWDecode",
b"ASCII85Decode",
b"ASCIIHexDecode",
b"RunLengthDecode",
];
fn content_filter_chain_is_generalized(dict: &Dictionary) -> bool {
fn is_generalized(name: &[u8]) -> bool {
GENERALIZED_FILTERS.contains(&name)
}
match dict.get("Filter") {
None => true,
Some(Object::Name(name)) => is_generalized(name),
Some(Object::Array(elems)) => elems
.iter()
.all(|e| matches!(e, Object::Name(n) if is_generalized(n))),
Some(_) => false,
}
}
fn check_content_streams<R: Read + Seek>(
pdf: &mut Pdf<R>,
diagnostics: &mut Diagnostics,
limits: DecodeLimits,
) {
let page_refs = match crate::pages::page_refs(pdf) {
Ok(refs) => refs,
Err(error) => {
diagnostics.push(Diagnostic::warning(
format!("could not enumerate pages for content-stream check: {error}"),
None,
));
return;
}
};
for (index, page_ref) in page_refs.iter().enumerate() {
let page_number = index + 1; let entries = match crate::pages::page_content_stream_entries(pdf, *page_ref) {
Ok(entries) => entries,
Err(error) => {
diagnostics.push(Diagnostic::warning(
format!("page {page_number}: could not read content streams: {error}"),
None,
));
continue;
}
};
for (stream_ref, stream) in entries {
if !content_filter_chain_is_generalized(&stream.dict) {
continue;
}
if let Err(error) = decode_stream_data_with_limits(&stream.dict, &stream.data, limits) {
let location = match stream_ref {
Some(r) => format!("content stream object {} {}", r.number, r.generation),
None => "inline content stream".to_string(),
};
if is_decode_output_limit_error(&error) {
let limit = limits.max_output.unwrap_or_default();
diagnostics.push(Diagnostic::warning(
format!(
"page {page_number}: {location}: decoded output exceeds the configured limit of {limit} bytes; skipped (decode-bomb guard)"
),
None,
));
} else {
diagnostics.push(Diagnostic::error(
format!(
"page {page_number}: {location}: errors while decoding content stream"
),
None,
));
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::filters::encode_stream_data;
use crate::{ObjectRef, Severity};
use std::io::Cursor;
#[test]
fn filter_chain_classification() {
let mut flate = Dictionary::new();
flate.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
assert!(content_filter_chain_is_generalized(&flate));
for codec in [
&b"LZWDecode"[..],
&b"ASCIIHexDecode"[..],
&b"RunLengthDecode"[..],
] {
let mut dict = Dictionary::new();
dict.insert("Filter", Object::Name(codec.to_vec()));
assert!(content_filter_chain_is_generalized(&dict));
}
let none = Dictionary::new();
assert!(content_filter_chain_is_generalized(&none));
let mut dct = Dictionary::new();
dct.insert("Filter", Object::Name(b"DCTDecode".to_vec()));
assert!(!content_filter_chain_is_generalized(&dct));
let mut mixed = Dictionary::new();
mixed.insert(
"Filter",
Object::Array(vec![
Object::Name(b"ASCII85Decode".to_vec()),
Object::Name(b"DCTDecode".to_vec()),
]),
);
assert!(!content_filter_chain_is_generalized(&mixed));
let mut all_generalized = Dictionary::new();
all_generalized.insert(
"Filter",
Object::Array(vec![
Object::Name(b"ASCII85Decode".to_vec()),
Object::Name(b"FlateDecode".to_vec()),
]),
);
assert!(content_filter_chain_is_generalized(&all_generalized));
let mut indirect = Dictionary::new();
indirect.insert("Filter", Object::Reference(ObjectRef::new(9, 0)));
assert!(!content_filter_chain_is_generalized(&indirect));
let mut weird = Dictionary::new();
weird.insert("Filter", Object::Integer(42));
assert!(!content_filter_chain_is_generalized(&weird));
}
fn minimal_pdf_bytes() -> 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();
pdf.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n"
)
.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 summary_present_for_clean_document() {
let report = check_reader_strict(Cursor::new(minimal_pdf_bytes())).unwrap();
assert!(report.valid);
let summary = report.summary.expect("summary present when document opens");
assert_eq!(summary.version, "1.4");
assert!(!summary.encrypted);
assert!(!summary.linearized);
assert_eq!(summary.extension_level, None);
}
fn extension_level_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.7\n");
let off1 = pdf.len();
pdf.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Extensions 4 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 off4 = pdf.len();
pdf.extend_from_slice(
b"4 0 obj\n<< /ADBE << /BaseVersion /1.7 /ExtensionLevel 8 >> >>\nendobj\n",
);
let xref_start = pdf.len();
pdf.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn summary_reports_adobe_extension_level() {
let report = check_reader_strict(Cursor::new(extension_level_pdf_bytes())).unwrap();
let summary = report.summary.expect("summary present");
assert_eq!(summary.version, "1.7");
assert_eq!(summary.extension_level, Some(8));
}
#[test]
fn summary_none_when_open_fails() {
let report = check_reader(Cursor::new(
b"%PDF-1.4\nthis is not a valid pdf at all\n%%EOF\n".to_vec(),
))
.unwrap();
assert!(!report.valid);
assert!(report.summary.is_none());
}
fn malformed_object1_pdf_bytes() -> 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\nthis is not a valid object\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();
pdf.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 2 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn linearization_probe_error_downgraded_to_warning() {
let report = check_reader_strict(Cursor::new(malformed_object1_pdf_bytes())).unwrap();
let summary = report
.summary
.expect("summary present: the document opened");
assert!(!summary.linearized);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Warning && d.message.contains("linearization hint")
}));
}
fn content_pdf(contents_entry: &str, extra_objects: &[(u32, Vec<u8>)]) -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /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;
let page_obj = format!(
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents {contents_entry} >>\nendobj\n"
);
pdf.extend_from_slice(page_obj.as_bytes());
let mut extra_offsets: Vec<u64> = Vec::new();
for (_, body) in extra_objects.iter() {
extra_offsets.push(pdf.len() as u64);
pdf.extend_from_slice(body);
}
let xref_start = pdf.len() as u64;
let total = 4 + extra_offsets.len();
let mut xref = format!("xref\n0 {total}\n0000000000 65535 f \n");
xref.push_str(&format!("{off1:010} 00000 n \n"));
xref.push_str(&format!("{off2:010} 00000 n \n"));
xref.push_str(&format!("{off3:010} 00000 n \n"));
for off in &extra_offsets {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn clean_flate_object(num: u32, body: &[u8]) -> Vec<u8> {
let mut flate_dict = Dictionary::new();
flate_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let encoded = encode_stream_data(&flate_dict, body).unwrap();
let mut out = Vec::new();
out.extend_from_slice(
format!(
"{num} 0 obj\n<< /Filter /FlateDecode /Length {} >>\nstream\n",
encoded.len()
)
.as_bytes(),
);
out.extend_from_slice(&encoded);
out.extend_from_slice(b"\nendstream\nendobj\n");
out
}
fn corrupt_filtered_object(num: u32, filter: &str, payload: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(
format!(
"{num} 0 obj\n<< /Filter /{filter} /Length {} >>\nstream\n",
payload.len()
)
.as_bytes(),
);
out.extend_from_slice(payload);
out.extend_from_slice(b"\nendstream\nendobj\n");
out
}
fn corrupt_flate_content_pdf() -> Vec<u8> {
content_pdf(
"4 0 R",
&[(
4,
corrupt_filtered_object(4, "FlateDecode", b"not a zlib stream at all"),
)],
)
}
fn corrupt_ascii85_content_pdf() -> Vec<u8> {
content_pdf(
"4 0 R",
&[(
4,
corrupt_filtered_object(4, "ASCII85Decode", b"abc\x7fdef~>"),
)],
)
}
fn content_array_one_corrupt_pdf() -> Vec<u8> {
content_pdf(
"[ 4 0 R 5 0 R ]",
&[
(4, clean_flate_object(4, b"BT /F1 12 Tf (ok) Tj ET")),
(
5,
corrupt_filtered_object(5, "FlateDecode", b"garbage not zlib"),
),
],
)
}
fn clean_flate_content_pdf() -> Vec<u8> {
content_pdf(
"4 0 R",
&[(4, clean_flate_object(4, b"BT /F1 12 Tf (hi) Tj ET"))],
)
}
fn bomb_flate_content_pdf(decoded_len: usize) -> Vec<u8> {
content_pdf(
"4 0 R",
&[(4, clean_flate_object(4, &vec![0u8; decoded_len]))],
)
}
fn corrupt_flate_image_object(num: u32) -> Vec<u8> {
let mut out = Vec::new();
let payload = b"garbage not a zlib stream";
out.extend_from_slice(
format!(
"{num} 0 obj\n<< /Type /XObject /Subtype /Image /Width 1 /Height 1 /BitsPerComponent 8 /ColorSpace /DeviceGray /Filter /FlateDecode /Length {} >>\nstream\n",
payload.len()
)
.as_bytes(),
);
out.extend_from_slice(payload);
out.extend_from_slice(b"\nendstream\nendobj\n");
out
}
fn corrupt_flate_image_pdf() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /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] /Contents 4 0 R /Resources << /XObject << /Im0 5 0 R >> >> >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(&clean_flate_object(
4,
b"BT /F1 12 Tf (hi) Tj ET q /Im0 Do Q",
));
let off5 = pdf.len() as u64;
pdf.extend_from_slice(&corrupt_flate_image_object(5));
let xref_start = pdf.len() as u64;
let mut xref = String::from("xref\n0 6\n0000000000 65535 f \n");
for off in [off1, off2, off3, off4, off5] {
xref.push_str(&format!("{off:010} 00000 n \n"));
}
pdf.extend_from_slice(xref.as_bytes());
pdf.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn dct_content_stream_pdf() -> Vec<u8> {
content_pdf(
"4 0 R",
&[(
4,
corrupt_filtered_object(4, "DCTDecode", b"not really jpeg bytes"),
)],
)
}
fn corrupt_inline_content_pdf() -> Vec<u8> {
let payload = b"not a zlib stream";
let contents = format!(
"<< /Filter /FlateDecode /Length {} >>\nstream\n{}\nendstream",
payload.len(),
std::str::from_utf8(payload).unwrap()
);
content_pdf(&contents, &[])
}
fn no_pages_entry_pdf() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(
format!("xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \n").as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
#[test]
fn corrupt_flate_content_stream_is_error() {
let report = check_reader_strict(Cursor::new(corrupt_flate_content_pdf())).unwrap();
assert!(!report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Error
&& d.message.contains("errors while decoding content stream")
}));
}
#[test]
fn corrupt_ascii85_content_stream_is_error() {
let report = check_reader_strict(Cursor::new(corrupt_ascii85_content_pdf())).unwrap();
assert!(!report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Error
&& d.message.contains("errors while decoding content stream")
}));
}
#[test]
fn content_array_with_one_corrupt_stream_is_error() {
let report = check_reader_strict(Cursor::new(content_array_one_corrupt_pdf())).unwrap();
assert!(!report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Error
&& d.message.contains("errors while decoding content stream")
&& d.message.contains("content stream object 5 0:")
}));
}
#[test]
fn clean_content_stream_keeps_valid() {
let report = check_reader_strict(Cursor::new(clean_flate_content_pdf())).unwrap();
assert!(report.valid);
assert!(!report
.diagnostics
.entries()
.iter()
.any(|d| d.message.contains("content stream")));
}
#[test]
fn corrupt_flate_image_xobject_not_checked() {
let report = check_reader_strict(Cursor::new(corrupt_flate_image_pdf())).unwrap();
assert!(report.valid);
}
#[test]
fn dct_content_stream_skipped_no_false_error() {
let report = check_reader_strict(Cursor::new(dct_content_stream_pdf())).unwrap();
assert!(report.valid);
assert!(!report
.diagnostics
.entries()
.iter()
.any(|d| d.message.contains("content stream")));
}
#[test]
fn corrupt_inline_content_stream_is_error() {
let report = check_reader_strict(Cursor::new(corrupt_inline_content_pdf())).unwrap();
assert!(!report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Error && d.message.contains("inline content stream")
}));
}
#[test]
fn page_enumeration_failure_downgraded_to_warning() {
let report = check_reader_strict(Cursor::new(no_pages_entry_pdf())).unwrap();
assert!(report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Warning
&& d.message
.contains("could not enumerate pages for content-stream check")
}));
}
#[test]
fn per_page_content_read_failure_downgraded_to_warning() {
let report = check_reader_strict(Cursor::new(content_pdf("42", &[]))).unwrap();
assert!(report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Warning && d.message.contains("could not read content streams")
}));
}
#[test]
fn decode_output_one_over_limit_warns_not_errors() {
let report = check_reader_with_options_and_limits(
Cursor::new(bomb_flate_content_pdf(1025)),
PdfOpenOptions {
repair: false,
..PdfOpenOptions::default()
},
crate::filters::DecodeLimits {
max_output: Some(1024),
},
)
.unwrap();
assert!(report.valid); assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Warning
&& d.message.contains("content stream object")
&& d.message.contains("decode-bomb guard")
}));
assert!(!report
.diagnostics
.entries()
.iter()
.any(|d| d.message.contains("errors while decoding content stream")));
}
#[test]
fn decode_output_exactly_at_limit_is_clean() {
let report = check_reader_with_options_and_limits(
Cursor::new(bomb_flate_content_pdf(1024)),
PdfOpenOptions {
repair: false,
..PdfOpenOptions::default()
},
crate::filters::DecodeLimits {
max_output: Some(1024),
},
)
.unwrap();
assert!(report.valid);
assert!(!report
.diagnostics
.entries()
.iter()
.any(|d| d.message.contains("content stream")));
}
#[test]
fn decode_limit_does_not_mask_corruption() {
let report = check_reader_with_options_and_limits(
Cursor::new(corrupt_flate_content_pdf()),
PdfOpenOptions {
repair: false,
..PdfOpenOptions::default()
},
crate::filters::DecodeLimits {
max_output: Some(1024),
},
)
.unwrap();
assert!(!report.valid);
assert!(report.diagnostics.entries().iter().any(|d| {
d.severity == Severity::Error
&& d.message.contains("errors while decoding content stream")
}));
}
#[test]
fn unlimited_default_decodes_large_stream_without_warning() {
let report = check_reader_with_options_and_limits(
Cursor::new(bomb_flate_content_pdf(64 * 1024)),
PdfOpenOptions {
repair: false,
..PdfOpenOptions::default()
},
crate::filters::DecodeLimits::default(),
)
.unwrap();
assert!(report.valid);
assert!(!report
.diagnostics
.entries()
.iter()
.any(|d| d.message.contains("content stream")));
}
}