Files
gridcraft/crates/pdf/src/tests.rs
T

1263 lines
52 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use super::*;
use std::error::Error;
use std::io;
mod reference;
use reference::{OldPage, interpret};
#[test]
fn rtl_marked_text_limit_fails_without_appending_partial_content() {
let mut doc = PdfDoc::new();
let page = doc.add_page(600.0, 300.0);
page.content = " ".repeat(MAX_PAGE_CONTENT - 8);
let before = page.content.len();
page.text_with_direction(Point::new(10.0, 20.0), 12.0, Font::Helvetica, [0, 0, 0], "ABC !", TextDirection::RightToLeft);
assert_eq!(page.content.len(), before, "the marked-content block must append atomically");
assert!(doc.finish().unwrap_err().to_string().contains("size limit"));
}
#[test]
fn a_paragraph_separator_keeps_right_to_left_latin_on_one_line() {
let visual = |text| arabic::latin_visual(text, TextDirection::RightToLeft).unwrap().into_owned();
assert_eq!(visual("ABC\r"), visual("ABC "));
assert_eq!(visual("ABC\u{2029}DEF"), visual("ABC DEF"));
}
#[test]
fn cjk_in_a_right_to_left_cell_keeps_the_cid_font() {
let mut doc = PdfDoc::new();
doc.add_page(600.0, 300.0).text_with_direction(Point::new(10.0, 20.0), 12.0, Font::Helvetica, [0, 0, 0], "编号!", TextDirection::RightToLeft);
let pdf = doc.finish().unwrap();
check_xref(&pdf).unwrap();
let cjk = find(&pdf, b"<7F1653F7> Tj").expect("CJK run set in the CID font");
assert!(find(&pdf, b"/Encoding /UniGB-UTF16-H").is_some());
assert!(find(&pdf, b"(!) Tj").is_some_and(|bang| bang < cjk), "the trailing ! is drawn left of the CJK run");
assert_eq!(utf16_entry(&pdf, "/ActualText").unwrap(), "编号!");
}
fn find(hay: &[u8], needle: &[u8]) -> Option<usize> {
hay.windows(needle.len()).position(|w| w == needle)
}
fn rfind(hay: &[u8], needle: &[u8]) -> Option<usize> {
hay.windows(needle.len()).rposition(|w| w == needle)
}
/// Parses the xref table back and checks each in-use entry points at `N 0 obj`.
fn check_xref(pdf: &[u8]) -> Result<usize, Box<dyn Error>> {
let sx = rfind(pdf, b"startxref\n").ok_or_else(|| io::Error::other("missing startxref"))?;
let rest = std::str::from_utf8(&pdf[sx + 10..])?;
let off: usize = rest.lines().next().ok_or_else(|| io::Error::other("missing xref offset"))?.trim().parse()?;
assert!(pdf[off..].starts_with(b"xref\n"), "startxref points at xref");
let table = std::str::from_utf8(&pdf[off..sx])?;
let mut lines = table.lines();
assert_eq!(lines.next(), Some("xref"));
let hdr: Vec<usize> =
lines.next().ok_or_else(|| io::Error::other("missing xref header"))?.split(' ').map(str::parse).collect::<Result<_, _>>()?;
assert_eq!(hdr.first(), Some(&0));
let count = *hdr.get(1).ok_or_else(|| io::Error::other("missing xref count"))?;
let mut checked = 0;
for i in 0..count {
let e = lines.next().ok_or_else(|| io::Error::other("missing xref entry"))?;
assert_eq!(e.len(), 19, "entry `{e}` (20 bytes with newline)");
let o: usize = e.get(..10).ok_or_else(|| io::Error::other("short xref offset"))?.parse()?;
if e.trim_end().ends_with('n') {
let want = format!("{i} 0 obj");
assert!(pdf[o..].starts_with(want.as_bytes()), "object {i} at {o}");
checked += 1;
}
}
assert!(table.contains("trailer"));
assert!(table.contains(&format!("/Size {count}")));
Ok(checked)
}
#[test]
fn minimal_document() -> Result<(), Box<dyn Error>> {
let pdf = PdfDoc::new().finish()?;
assert!(pdf.starts_with(b"%PDF-1.7"));
assert!(pdf.ends_with(b"%%EOF\n"));
assert!(check_xref(&pdf)? >= 5);
Ok(())
}
#[test]
fn drawing_and_text() -> Result<(), Box<dyn Error>> {
let mut d = PdfDoc::new();
d.info.title = "Report (Q1)".into();
let p = d.add_page(612.0, 792.0);
p.fill_rect(10.0, 10.0, 100.0, 20.0, [255, 255, 0]);
p.rect_stroke(10.0, 10.0, 100.0, 20.0, 0.5, [0, 0, 0]);
p.stroke_line(0.0, 0.0, 612.0, 792.0, 1.0, [255, 0, 0]);
p.stroke_line_dashed(Point::new(0.0, 5.0), Point::new(100.0, 5.0), 1.0, [0, 0, 0], &[3.0, 2.0]);
p.polygon(&[[0.0, 0.0], [10.0, 0.0], [5.0, 8.0]], Some([0, 0, 255]), Some(([0, 0, 0], 1.0)));
p.circle(300.0, 300.0, 20.0, Some([0, 128, 0]), None);
p.save();
p.clip_rect(0.0, 0.0, 50.0, 50.0);
p.text(72.0, 72.0, 12.0, Font::Helvetica, [0, 0, 0], "Hello (world) \\ café €5");
p.restore();
p.text_rotated(Point::new(100.0, 100.0), 9.0, Font::TimesBold, [0, 0, 0], "Up", -std::f32::consts::FRAC_PI_2);
let p2 = d.add_page(842.0, 595.0);
p2.text(10.0, 20.0, 10.0, Font::CourierBold, [0, 0, 0], "Second");
assert_eq!(d.page_count(), 2);
let pdf = d.finish()?;
check_xref(&pdf)?;
assert!(find(&pdf, b"(Hello \\(world\\) \\\\ caf\\351 \\2005) Tj").is_some());
assert!(find(&pdf, b"(Second) Tj").is_some());
assert!(find(&pdf, b"/BaseFont /Helvetica /Encoding /WinAnsiEncoding").is_some());
assert!(find(&pdf, b"/BaseFont /Courier-Bold").is_some());
assert!(find(&pdf, b"/BaseFont /Times-Bold").is_some());
assert!(find(&pdf, b"/Count 2").is_some());
assert!(find(&pdf, b"/MediaBox [0 0 842 595]").is_some());
assert!(find(&pdf, b"/Title (Report \\(Q1\\))").is_some());
// Top-left origin: a line from (0,0) starts at the top of the page.
assert!(find(&pdf, b"0 792 m 612 0 l S").is_some());
Ok(())
}
#[test]
fn uri_and_page_links_are_real_pdf_annotations() -> Result<(), Box<dyn Error>> {
let mut d = PdfDoc::new();
let first = d.add_page(200.0, 300.0);
first.link_uri(10.0, 20.0, 80.0, 30.0, "https://example.org/a(b)?q=£");
first.link_page(Rect::new(100.0, 40.0, 50.0, 20.0), 1, Point::new(35.0, 60.0));
first.link_uri(-20.0, -20.0, 40.0, 40.0, "mailto:a@example.org");
first.link_uri(0.0, 0.0, f32::NAN, 10.0, "https://bad.example");
first.link_uri(0.0, 0.0, 10.0, 10.0, "javascript:alert(1)");
let second = d.add_page(100.0, 200.0);
second.link_page(Rect::new(0.0, 0.0, 10.0, 10.0), 99, Point::new(0.0, 0.0));
let pdf = d.finish()?;
check_xref(&pdf)?;
let s = String::from_utf8_lossy(&pdf);
assert_eq!(s.matches("/Subtype /Link").count(), 3);
assert!(s.contains("/Annots ["));
assert!(s.contains("/Rect [10 250 90 280]"));
assert!(s.contains("/Rect [0 280 20 300]"));
assert!(s.contains("/URI (https://example.org/a\\(b\\)?q=%C2%A3)"));
assert!(s.contains("/XYZ 35 140 null"));
assert!(!s.contains("https://bad.example"));
Ok(())
}
#[test]
fn images_with_alpha() -> Result<(), Box<dyn Error>> {
let mut d = PdfDoc::new();
let p = d.add_page(200.0, 200.0);
let mut px = Vec::new();
for i in 0..16u8 {
px.extend_from_slice(&[i * 10, 0, 0, if i < 8 { 255 } else { 128 }]);
}
p.image_rgba(Rect::new(10.0, 10.0, 40.0, 40.0), &px, [4, 4]);
p.image_rgba(Rect::new(10.0, 10.0, 40.0, 40.0), &[255; 16], [2, 2]); // opaque: no mask
p.image_rgba(Rect::new(0.0, 0.0, 1.0, 1.0), &[1, 2, 3], [4, 4]); // too short: ignored
let pdf = d.finish()?;
check_xref(&pdf)?;
assert!(find(&pdf, b"/SMask").is_some());
assert!(find(&pdf, b"/Im1 Do").is_some());
assert!(find(&pdf, b"/Im2 Do").is_some());
assert!(find(&pdf, b"/Im3").is_none());
Ok(())
}
#[test]
fn run_length_roundtrip() {
fn decode(d: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut i = 0;
while i < d.len() {
let l = d[i];
i += 1;
if l == 128 {
break;
} else if l < 128 {
out.extend_from_slice(&d[i..i + l as usize + 1]);
i += l as usize + 1;
} else {
out.extend(std::iter::repeat_n(d[i], 257 - l as usize));
i += 1;
}
}
out
}
let cases: Vec<Vec<u8>> = vec![
vec![],
vec![1],
vec![1, 1],
vec![1, 2, 3, 3, 3, 3, 4, 5, 5],
(0..1000).map(|i| (i / 7) as u8).collect(),
(0..1000).map(|i| (i * 31 % 251) as u8).collect(),
vec![9; 300],
];
for c in cases {
assert_eq!(decode(&run_length(&c)), c);
}
}
#[test]
fn widths() {
assert!((text_width(Font::Helvetica, 10.0, "Hello") - 22.78).abs() < 0.01);
assert!(text_width(Font::HelveticaBold, 10.0, "Hello") > text_width(Font::Helvetica, 10.0, "Hello"));
assert_eq!(text_width(Font::Courier, 10.0, "abc"), 18.0);
assert!(text_width(Font::TimesRoman, 12.0, "é") > 0.0);
assert_eq!(text_width(Font::Helvetica, 10.0, ""), 0.0);
assert_eq!(Font::family_for("Calibri"), Family::Sans);
assert_eq!(Font::family_for("Times New Roman"), Family::Serif);
assert_eq!(Font::family_for("Consolas"), Family::Mono);
assert_eq!(Font::styled(Family::Serif, true, true), Font::TimesBoldItalic);
}
#[test]
fn hostile_inputs_never_panic() -> Result<(), Box<dyn Error>> {
let mut d = PdfDoc::new();
let p = d.add_page(f32::NAN, -5.0);
p.text(f32::INFINITY, f32::NAN, 1e30, Font::Helvetica, [0, 0, 0], "x");
p.fill_rect(0.0, 0.0, -1.0, 5.0, [0, 0, 0]);
p.polygon(&[], None, None);
p.circle(0.0, 0.0, -3.0, Some([0, 0, 0]), None);
p.restore();
p.restore();
p.save();
p.image_rgba(Rect::new(0.0, 0.0, 10.0, 10.0), &[], [u32::MAX, u32::MAX]);
let pdf = d.finish()?;
check_xref(&pdf)?;
Ok(())
}
// ---------------------------------------------------------------------------------------------
// Writer cleanup: equivalence with the previous content writer, structure, and one test per
// behaviour change.
// ---------------------------------------------------------------------------------------------
/// Offsets of the in-use objects, by id, from the xref table.
fn xref_offsets(pdf: &[u8]) -> Vec<usize> {
let sx = rfind(pdf, b"startxref\n").unwrap();
let rest = std::str::from_utf8(&pdf[sx + 10..]).unwrap();
let off: usize = rest.lines().next().unwrap().trim().parse().unwrap();
let table = std::str::from_utf8(&pdf[off..sx]).unwrap();
table.lines().skip(2).take_while(|l| l.len() == 18 || l.len() == 19).map(|e| e[..10].parse().unwrap()).collect()
}
struct Obj {
dict: String,
stream: Option<Vec<u8>>,
}
/// Parses every object of a document written by this crate, checking that each stream's
/// `/Length` matches its data and is followed by `endstream`/`endobj`.
fn parse_objects(pdf: &[u8]) -> Vec<Obj> {
let offsets = xref_offsets(pdf);
let mut objs = Vec::new();
for (id, off) in offsets.iter().enumerate() {
if id == 0 {
objs.push(Obj { dict: String::new(), stream: None });
continue;
}
let tail = &pdf[*off..];
let head = format!("{id} 0 obj\n");
assert!(tail.starts_with(head.as_bytes()), "object {id}");
let body = &tail[head.len()..];
let end = find(body, b"\nendobj\n").unwrap();
match find(body, b"\nstream\n").filter(|s| *s < end) {
Some(s) => {
let dict = String::from_utf8(body[..s].to_vec()).unwrap();
let l = dict.find("/Length ").unwrap() + 8;
let len: usize = dict[l..].split(' ').next().unwrap().parse().unwrap();
let data = &body[s + 8..];
assert!(data[len..].starts_with(b"\nendstream\nendobj\n"), "object {id}: /Length {len} is wrong");
objs.push(Obj { dict, stream: Some(data[..len].to_vec()) });
}
None => objs.push(Obj { dict: String::from_utf8(body[..end].to_vec()).unwrap(), stream: None }),
}
}
objs
}
fn ref_of(dict: &str, key: &str) -> Option<usize> {
let i = dict.find(key)? + key.len();
dict[i..].trim_start().split(' ').next()?.parse().ok()
}
struct ParsedPage {
media: String,
content: String,
/// `(Im name, object id)`.
xobjects: Vec<(String, usize)>,
}
fn parse_pages(pdf: &[u8]) -> (Vec<Obj>, Vec<ParsedPage>) {
let objs = parse_objects(pdf);
let mut pages = Vec::new();
for o in &objs {
if !o.dict.contains("/Type /Page ") {
continue;
}
let m = o.dict.find("/MediaBox [").unwrap() + 10;
let media = o.dict[m..m + o.dict[m..].find(']').unwrap() + 1].to_string();
let content_id = ref_of(&o.dict, "/Contents").unwrap();
let content = String::from_utf8(objs[content_id].stream.clone().unwrap()).unwrap();
let mut xobjects = Vec::new();
if let Some(x) = o.dict.find("/XObject << ") {
let rest = &o.dict[x + 11..];
let rest = &rest[..rest.find(">>").unwrap()];
let toks: Vec<&str> = rest.split_whitespace().collect();
for c in toks.chunks(4) {
xobjects.push((c[0].to_string(), c[1].parse().unwrap()));
}
}
pages.push(ParsedPage { media, content, xobjects });
}
(objs, pages)
}
fn rle_decode(d: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut i = 0;
while i < d.len() {
let l = d[i];
i += 1;
if l == 128 {
break;
} else if l < 128 {
out.extend_from_slice(&d[i..i + l as usize + 1]);
i += l as usize + 1;
} else {
out.extend(std::iter::repeat_n(d[i], 257 - l as usize));
i += 1;
}
}
out
}
/// Decodes an image XObject: `(width, height, rgb, alpha)`.
fn decode_image(objs: &[Obj], id: usize) -> (u32, u32, Vec<u8>, Option<Vec<u8>>) {
let o = &objs[id];
let w = ref_of(&o.dict, "/Width").unwrap() as u32;
let h = ref_of(&o.dict, "/Height").unwrap() as u32;
let rgb = rle_decode(o.stream.as_ref().unwrap());
let alpha = ref_of(&o.dict, "/SMask").map(|m| rle_decode(objs[m].stream.as_ref().unwrap()));
(w, h, rgb, alpha)
}
/// Deterministic pseudo-random numbers for the corpus.
struct Lcg(u64);
impl Lcg {
fn next(&mut self) -> u64 {
self.0 = self.0.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
self.0 >> 33
}
fn below(&mut self, n: u64) -> u64 {
self.next() % n
}
fn f(&mut self) -> f32 {
self.below(600) as f32 + self.below(4) as f32 * 0.25
}
}
const PALETTE: [Rgb; 4] = [[0, 0, 0], [255, 0, 0], [12, 200, 99], [255, 255, 255]];
const WIDTHS: [f32; 3] = [0.5, 1.0, 2.5];
const DASHES: [&[f32]; 3] = [&[], &[3.0, 2.0], &[1.0]];
/// A picture used by the corpus: `(rgba, w, h)`.
fn pictures() -> Vec<(Vec<u8>, u32, u32)> {
let mut with_alpha = Vec::new();
for i in 0..16u8 {
with_alpha.extend_from_slice(&[i * 10, 0, 7, if i < 8 { 255 } else { 128 }]);
}
let opaque: Vec<u8> = (0..4 * 9).map(|i| if i % 4 == 3 { 255 } else { (i * 7) as u8 }).collect();
let mut last_px = vec![200u8; 4 * 6];
for px in last_px.chunks_mut(4) {
px[3] = 255;
}
last_px[4 * 5 + 3] = 3; // only the very last pixel is translucent
vec![(with_alpha, 4, 4), (opaque, 3, 3), (last_px, 3, 2)]
}
/// Applies a random operation to both writers.
fn random_op(rng: &mut Lcg, new: &mut Page, old: &mut OldPage, pics: &[(Vec<u8>, u32, u32)], depth: &mut usize) {
let color = PALETTE[rng.below(4) as usize];
let width = WIDTHS[rng.below(3) as usize];
let dash = DASHES[rng.below(3) as usize];
let (x, y, w, h) = (rng.f(), rng.f(), rng.f() / 4.0 + 1.0, rng.f() / 4.0 + 1.0);
let pts = [[x, y], [x + w, y], [x + w, y + h]];
let stroke = if rng.below(2) == 0 { Some((PALETTE[rng.below(4) as usize], WIDTHS[rng.below(3) as usize])) } else { None };
let fill = if rng.below(2) == 0 { Some(color) } else { None };
match rng.below(14) {
0 | 1 => {
new.fill_rect(x, y, w, h, color);
old.fill_rect(x, y, w, h, color);
}
2 => {
new.rect_stroke(x, y, w, h, width, color);
old.rect_stroke(x, y, w, h, width, color);
}
3 => {
new.stroke_line_dashed(Point::new(x, y), Point::new(x + w, y + h), width, color, dash);
old.stroke_line_dashed(Point::new(x, y), Point::new(x + w, y + h), width, color, dash);
}
4 => {
new.polyline(&pts, width, color, dash);
old.polyline(&pts, width, color, dash);
}
5 => {
new.polygon(&pts, fill, stroke);
old.polygon(&pts, fill, stroke);
}
6 => {
new.circle(x, y, w, fill, stroke);
old.circle(x, y, w, fill, stroke);
}
7 | 8 => {
let font = Font::ALL[rng.below(12) as usize];
let angle = if rng.below(3) == 0 { 0.5 } else { 0.0 };
new.text_rotated(Point::new(x, y), 10.0, font, color, "Hi (there)", angle);
old.text_rotated(Point::new(x, y), 10.0, font, color, "Hi (there)", angle);
}
9 => {
new.clip_rect(x, y, w, h);
old.clip_rect(x, y, w, h);
}
10 if *depth < 20 => {
new.save();
old.save();
*depth += 1;
}
11 if *depth > 0 => {
new.restore();
old.restore();
*depth -= 1;
}
12 => {
let (px, pw, ph) = &pics[rng.below(3) as usize];
new.image_rgba(Rect::new(x, y, w, h), px, [*pw, *ph]);
old.image(x, y, w, h);
}
_ => {
new.text(x, y, 9.0, Font::Helvetica, color, "Plain");
old.text_rotated(Point::new(x, y), 9.0, Font::Helvetica, color, "Plain", 0.0);
}
}
}
/// Builds the same random multi-page document with the new writer and the old content writer.
fn corpus_doc(seed: u64) -> (Vec<u8>, Vec<String>) {
let mut rng = Lcg(seed);
let pics = pictures();
let mut doc = PdfDoc::new();
let mut old_pages = Vec::new();
for _ in 0..(1 + rng.below(4)) {
let mut old = OldPage::new(792.0);
let mut depth = 0usize;
let page = doc.add_page(612.0, 792.0);
for _ in 0..120 {
random_op(&mut rng, page, &mut old, &pics, &mut depth);
}
while depth > 0 {
page.restore();
old.restore();
depth -= 1;
}
old_pages.push(old.content);
}
(doc.finish().unwrap(), old_pages)
}
#[test]
fn new_writer_is_equivalent_to_the_old_one() -> Result<(), Box<dyn Error>> {
let mut style_new = 0;
let mut style_old = 0;
for seed in 1..=40u64 {
let (pdf, old_pages) = corpus_doc(seed);
check_xref(&pdf)?;
let (_, pages) = parse_pages(&pdf);
assert_eq!(pages.len(), old_pages.len());
for (p, old) in pages.iter().zip(&old_pages) {
assert_eq!(p.media, "[0 0 612 792]");
let new = interpret(&p.content);
let old = interpret(old);
assert!(new.balanced && old.balanced, "q/Q balanced (seed {seed})");
assert_eq!(new.paints.len(), old.paints.len(), "seed {seed}");
for (i, (a, b)) in new.paints.iter().zip(&old.paints).enumerate() {
// Round joins leaking from polylines into later rectangles is the old bug (B7),
// compared separately in `join_does_not_leak_from_polylines`.
let mut a = a.clone();
let mut b = b.clone();
a.join.clear();
b.join.clear();
assert_eq!(a, b, "seed {seed}, painting op {i}");
}
style_new += new.style_ops;
style_old += old.style_ops;
}
}
// Sanity: the corpus really contains style changes, and the new writer emits fewer.
assert!(style_old > 1000, "corpus too small: {style_old}");
assert!(style_new < style_old, "{style_new} vs {style_old}");
Ok(())
}
#[test]
fn structure_is_valid_for_all_documents() -> Result<(), Box<dyn Error>> {
for seed in 1..=40u64 {
let (pdf, _) = corpus_doc(seed);
check_xref(&pdf)?;
parse_objects(&pdf); // every /Length matches its data
}
let empty = PdfDoc::new().finish()?;
check_xref(&empty)?;
parse_objects(&empty);
Ok(())
}
#[test]
fn images_decode_to_their_pixels() {
let pics = pictures();
let mut d = PdfDoc::new();
for _ in 0..2 {
let p = d.add_page(300.0, 300.0);
for (px, w, h) in &pics {
p.image_rgba(Rect::new(1.0, 1.0, 20.0, 20.0), px, [*w, *h]);
}
}
let pdf = d.finish().unwrap();
let (objs, pages) = parse_pages(&pdf);
assert_eq!(pages.len(), 2);
for page in &pages {
assert_eq!(page.xobjects.len(), 3);
for ((px, w, h), (_, id)) in pics.iter().zip(&page.xobjects) {
let (dw, dh, rgb, alpha) = decode_image(&objs, *id);
assert_eq!((dw, dh), (*w, *h));
let want_rgb: Vec<u8> = px.chunks(4).flat_map(|c| [c[0], c[1], c[2]]).collect();
assert_eq!(rgb, want_rgb);
let want_alpha: Vec<u8> = px.chunks(4).map(|c| c[3]).collect();
match alpha {
Some(a) => assert_eq!(a, want_alpha),
None => assert!(want_alpha.iter().all(|a| *a == 255)),
}
}
}
}
/// O6: no alpha plane (and no SMask object) for an opaque image; a single translucent pixel
/// anywhere (first, middle, last) produces the full plane.
#[test]
fn opaque_images_have_no_soft_mask() {
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
p.image_rgba(Rect::new(0.0, 0.0, 10.0, 10.0), &[255; 4 * 12], [4, 3]);
assert!(p.images[0].alpha.is_none());
let pdf = d.finish().unwrap();
assert!(find(&pdf, b"/SMask").is_none());
assert_eq!(pdf.windows(15).filter(|w| *w == b"/Subtype /Image").count(), 1);
for translucent in [0usize, 5, 11] {
let mut px = vec![255u8; 4 * 12];
px[translucent * 4 + 3] = 7;
let mut d = PdfDoc::new();
d.add_page(100.0, 100.0).image_rgba(Rect::new(0.0, 0.0, 10.0, 10.0), &px, [4, 3]);
let (objs, pages) = parse_pages(&d.finish().unwrap());
let (_, _, _, alpha) = decode_image(&objs, pages[0].xobjects[0].1);
let mut want = vec![255u8; 12];
want[translucent] = 7;
assert_eq!(alpha, Some(want));
}
}
/// O4: the same picture on five pages is stored once (image + mask), by every page.
#[test]
fn identical_images_are_stored_once() -> Result<(), Box<dyn Error>> {
let pics = pictures();
let (px, w, h) = &pics[0]; // has alpha: image object + mask object
let mut d = PdfDoc::new();
for _ in 0..5 {
let p = d.add_page(200.0, 200.0);
p.image_rgba(Rect::new(1.0, 1.0, 20.0, 20.0), px, [*w, *h]);
p.image_rgba(Rect::new(30.0, 1.0, 20.0, 20.0), px, [*w, *h]); // twice on one page
}
let pdf = d.finish()?;
check_xref(&pdf)?;
assert_eq!(pdf.windows(15).filter(|w| *w == b"/Subtype /Image").count(), 2, "one image + one soft mask");
let (_, pages) = parse_pages(&pdf);
let ids: Vec<usize> = pages.iter().flat_map(|p| p.xobjects.iter().map(|x| x.1)).collect();
assert_eq!(ids.len(), 5, "one XObject entry per page");
assert!(ids.iter().all(|i| *i == ids[0]));
for p in &pages {
assert_eq!(p.content.matches(" Do").count(), 2);
}
Ok(())
}
/// O4: a picture that differs in one byte, or only in size, is not merged.
#[test]
fn different_images_are_not_merged() {
let a = vec![50u8; 4 * 4];
let mut b = a.clone();
b[5] = 51;
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
p.image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &a, [4, 1]);
p.image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &b, [4, 1]);
p.image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &a, [2, 2]);
d.add_page(100.0, 100.0).image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &a, [4, 1]);
let pdf = d.finish().unwrap();
assert_eq!(pdf.windows(15).filter(|w| *w == b"/Subtype /Image").count(), 6, "three distinct pictures, each with a soft mask (alpha 50)");
}
/// O4: many distinct pictures on one page are looked up by hash, not by comparing each new
/// picture with every earlier one (which made dense picture exports quadratic).
#[test]
fn many_distinct_images_on_one_page_are_not_compared_pairwise() {
const N: u32 = 3000;
let mut d = PdfDoc::new();
let p = d.add_page(612.0, 792.0);
for i in 0..N {
let [a, b, c, _] = i.to_le_bytes();
p.image_rgba(Rect::new(0.0, 0.0, 1.0, 1.0), &[a, b, c, 255], [1, 1]);
}
// A repeat of the first picture still shares its XObject.
p.image_rgba(Rect::new(5.0, 5.0, 1.0, 1.0), &[0, 0, 0, 255], [1, 1]);
assert_eq!(p.images.len(), N as usize);
assert!(p.content.ends_with("/Im1 Do Q\n"), "the repeated picture reuses /Im1");
assert!(p.image_comparisons <= 1, "{} pixel comparisons for {N} distinct pictures", p.image_comparisons);
let pdf = d.finish().unwrap();
assert_eq!(pdf.windows(15).filter(|w| *w == b"/Subtype /Image").count(), N as usize);
}
/// O4: equal hashes alone never merge images; the pixels are compared.
#[test]
fn hash_collisions_do_not_merge_images() {
let mut d = PdfDoc::new();
for v in [10u8, 20] {
d.add_page(100.0, 100.0).image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &[v; 16], [2, 2]);
}
for p in 0..2 {
d.page_mut(p).unwrap().images[0].hash = 42; // forced collision
}
let (objs, pages) = parse_pages(&d.finish().unwrap());
let ids: Vec<usize> = pages.iter().map(|p| p.xobjects[0].1).collect();
assert_ne!(ids[0], ids[1]);
assert_eq!(decode_image(&objs, ids[0]).2, vec![10; 12]);
assert_eq!(decode_image(&objs, ids[1]).2, vec![20; 12]);
}
/// S5: the colour component table equals the old float formatting for every byte.
#[test]
fn colour_components_match_the_float_formatting() {
for v in 0..=255u8 {
let mut s = String::new();
push_unit(&mut s, v);
assert_eq!(s, n(v as f32 / 255.0), "byte {v}");
}
let mut s = String::new();
push_rgb(&mut s, [255, 128, 0], true);
assert_eq!(s, "1 0.502 0 RG");
}
/// S3: the obsolete /ProcSet entry is gone.
#[test]
fn no_procset() {
let (pdf, _) = corpus_doc(3);
assert!(find(&pdf, b"/ProcSet").is_none());
}
/// O3: a style that is already in effect is not emitted again.
#[test]
fn unchanged_style_is_emitted_once() {
let mut d = PdfDoc::new();
let p = d.add_page(200.0, 200.0);
for i in 0..50 {
p.rect_stroke(i as f32, 0.0, 5.0, 5.0, 1.5, [10, 20, 30]);
}
for i in 0..50 {
p.stroke_line_dashed(Point::new(0.0, i as f32), Point::new(9.0, 9.0), 1.5, [10, 20, 30], &[2.0, 1.0]);
}
for _ in 0..50 {
p.fill_rect(0.0, 0.0, 4.0, 4.0, [1, 2, 3]);
p.text(5.0, 5.0, 9.0, Font::Helvetica, [1, 2, 3], "x");
}
let s = interpret(&p.content);
assert_eq!(p.content.matches(" RG\n").count(), 1);
assert_eq!(p.content.matches(" rg\n").count(), 1);
assert_eq!(p.content.matches(" w\n").count(), 1);
assert_eq!(p.content.matches(" d\n").count(), 2, "solid, then [2 1]");
assert_eq!(s.style_ops, 5);
assert_eq!(s.paints.len(), 50 * 4);
}
/// O3: the tracked style follows q/Q, and a new page starts from scratch.
#[test]
fn style_tracking_follows_save_restore_and_pages() {
let red = [255, 0, 0];
let blue = [0, 0, 255];
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
p.fill_rect(0.0, 0.0, 5.0, 5.0, red);
p.save();
p.fill_rect(0.0, 0.0, 5.0, 5.0, red); // still red inside: nothing to emit
p.fill_rect(0.0, 0.0, 5.0, 5.0, blue);
p.restore();
p.fill_rect(0.0, 0.0, 5.0, 5.0, red); // red again after Q without a new operator
p.fill_rect(0.0, 0.0, 5.0, 5.0, blue); // but blue must be re-emitted
let fills: Vec<String> = interpret(&p.content).paints.iter().map(|p| p.fill.clone()).collect();
assert_eq!(fills, ["1 0 0", "1 0 0", "0 0 1", "1 0 0", "0 0 1"]);
assert_eq!(p.content.matches(" rg\n").count(), 3, "red once, blue twice");
let p2 = d.add_page(100.0, 100.0);
p2.fill_rect(0.0, 0.0, 5.0, 5.0, red);
assert_eq!(p2.content.matches(" rg\n").count(), 1, "a new page re-emits the colour");
}
/// B6: only 28 nested saves are written, the matching extra restores are no-ops.
#[test]
fn save_nesting_is_limited_to_28() -> Result<(), Box<dyn Error>> {
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
for _ in 0..40 {
p.save();
}
p.fill_rect(0.0, 0.0, 5.0, 5.0, [1, 1, 1]);
assert_eq!(p.content.matches("q\n").count(), 28);
// The 12 restores that match refused saves do nothing...
for _ in 0..12 {
p.restore();
}
assert_eq!(p.content.matches("Q\n").count(), 0);
assert_eq!(interpret(&p.content).max_depth, 28);
// ...the next 28 undo the accepted ones, and further restores are ignored.
for _ in 0..40 {
p.restore();
}
assert_eq!(p.content.matches("Q\n").count(), 28);
let i = interpret(&p.content);
assert!(i.balanced);
// An image needs its own q: dropped at the limit, drawn otherwise.
for _ in 0..28 {
p.save();
}
p.image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &[9; 16], [2, 2]);
assert!(!p.content.contains(" Do"));
p.restore();
p.image_rgba(Rect::new(0.0, 0.0, 5.0, 5.0), &[9; 16], [2, 2]);
assert!(p.content.contains(" Do"));
let pdf = d.finish()?;
check_xref(&pdf)?;
Ok(())
}
/// B6: `finish()` closes what is still open, without exceeding the limit.
#[test]
fn finish_closes_open_saves() -> Result<(), Box<dyn Error>> {
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
for _ in 0..33 {
p.save();
}
let (_, pages) = parse_pages(&d.finish()?);
let i = interpret(&pages[0].content);
assert!(i.balanced);
assert_eq!(i.qs, 28);
Ok(())
}
/// B7: round joins set for a polyline do not leak into later rectangles, lines and circles.
#[test]
fn join_does_not_leak_from_polylines() {
let mut d = PdfDoc::new();
let p = d.add_page(200.0, 200.0);
let pts = [[0.0, 0.0], [10.0, 0.0], [10.0, 10.0]];
p.rect_stroke(0.0, 0.0, 5.0, 5.0, 1.0, [0, 0, 0]);
p.polyline(&pts, 1.0, [0, 0, 0], &[]);
p.polyline(&pts, 1.0, [0, 0, 0], &[]);
p.rect_stroke(0.0, 0.0, 5.0, 5.0, 1.0, [0, 0, 0]);
p.stroke_line(0.0, 0.0, 9.0, 9.0, 1.0, [0, 0, 0]);
p.polygon(&pts, None, Some(([0, 0, 0], 1.0)));
p.circle(50.0, 50.0, 5.0, None, Some(([0, 0, 0], 1.0)));
let joins: Vec<String> = interpret(&p.content).paints.iter().map(|p| p.join.clone()).collect();
assert_eq!(joins, ["0", "1", "1", "0", "0", "1", "0"]);
assert_eq!(p.content.matches(" j\n").count(), 4, "1, 0, 1, 0: only on change");
}
fn page_content(d: &PdfDoc) -> &str {
&d.pages[0].content
}
#[test]
fn text_width_does_not_overflow() {
// 8,000,000 x 556 units exceeds u32::MAX: a u32 sum panics in debug builds.
let long = "a".repeat(8_000_000);
let w = text_width(Font::Helvetica, 10.0, &long);
assert!(w.is_finite() && w > 0.0);
assert!(w > text_width(Font::Helvetica, 10.0, &"a".repeat(7_000_000)));
}
#[test]
fn all_zero_dash_is_drawn_solid() {
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
p.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(50.0, 0.0), 1.0, [0, 0, 0], &[0.0, 0.0]);
p.polyline(&[[0.0, 0.0], [5.0, 5.0]], 1.0, [0, 0, 0], &[0.0, 0.0001, f32::NAN]);
p.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(50.0, 0.0), 1.0, [0, 0, 0], &[3.0, 2.0]);
let c = page_content(&d);
// The writer emits style operators only on change: the two solid lines share one `[] 0 d`.
let dashes: Vec<String> = interpret(c).paints.iter().map(|p| p.dash.clone()).collect();
assert_eq!(dashes, ["", "", "3 2"]);
assert_eq!(c.matches("[] 0 d").count(), 1);
assert!(!c.contains("[0 0]"));
assert!(c.contains("[3 2] 0 d"));
}
#[test]
fn negative_and_nan_stroke_widths_become_zero() {
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
p.rect_stroke(1.0, 1.0, 10.0, 10.0, -3.0, [0, 0, 0]);
p.stroke_line(0.0, 0.0, 5.0, 5.0, f32::NAN, [0, 0, 0]);
p.polygon(&[[0.0, 0.0], [5.0, 0.0], [5.0, 5.0]], None, Some(([0, 0, 0], -1.0)));
p.circle(20.0, 20.0, 5.0, None, Some(([0, 0, 0], f32::NEG_INFINITY)));
let c = page_content(&d);
// Style operators are emitted only on change, so judge the width in effect for each stroke.
let widths: Vec<String> = interpret(c).paints.iter().map(|p| p.width.clone()).collect();
assert_eq!(widths, ["0", "0", "0", "0"]);
assert!(!c.contains("-1 w") && !c.contains("-3 w"));
}
#[test]
fn non_finite_image_size_stores_nothing() {
let mut d = PdfDoc::new();
let p = d.add_page(200.0, 200.0);
let px = [255u8; 16];
for (w, h) in [(f32::NAN, 10.0), (10.0, f32::NAN), (f32::INFINITY, 10.0), (-1.0, 10.0)] {
p.image_rgba(Rect::new(0.0, 0.0, w, h), &px, [2, 2]);
}
p.image_rgba(Rect::new(f32::NAN, 0.0, 10.0, 10.0), &px, [2, 2]);
assert!(p.images.is_empty());
assert!(p.content.is_empty());
}
#[test]
fn every_draw_method_survives_hostile_numbers() -> Result<(), Box<dyn Error>> {
let bad = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -7.0, 0.0, 1.0e30, -1.0e30];
let px = [200u8; 16];
let mut d = PdfDoc::new();
let p = d.add_page(300.0, 300.0);
for &a in &bad {
for &b in &bad {
p.clip_rect(a, b, a, b);
p.fill_rect(a, b, b, a, [1, 2, 3]);
p.rect_stroke(a, b, a, b, a, [1, 2, 3]);
p.stroke_line(a, b, b, a, a, [1, 2, 3]);
p.stroke_line_dashed(Point::new(a, b), Point::new(b, a), b, [1, 2, 3], &[a, b, 0.0]);
p.polyline(&[[a, b], [b, a], [1.0, 1.0]], a, [1, 2, 3], &[b, a]);
p.polygon(&[[a, b], [b, a], [1.0, 1.0]], Some([1, 2, 3]), Some(([4, 5, 6], a)));
p.circle(a, b, b, Some([1, 2, 3]), Some(([4, 5, 6], a)));
p.text(a, b, a, Font::Helvetica, [0, 0, 0], "x");
p.text_rotated(Point::new(a, b), 10.0, Font::TimesRoman, [0, 0, 0], "y", b);
p.image_rgba(Rect::new(a, b, b, a), &px, [2, 2]);
}
}
p.stroke_line_dashed(Point::new(0.0, 0.0), Point::new(1.0, 1.0), 1.0, [0, 0, 0], &[0.0; 100]);
let c = page_content(&d);
assert!(!c.contains("NaN") && !c.contains("inf"));
let pdf = d.finish()?;
check_xref(&pdf)?;
Ok(())
}
/// Decodes the `<FEFF…>` hex string following `key` in the file bytes.
fn utf16_entry(pdf: &[u8], key: &str) -> Result<String, Box<dyn Error>> {
let at = find(pdf, key.as_bytes()).ok_or_else(|| io::Error::other("missing PDF info key"))? + key.len();
let end = at + 9000.min(pdf.len() - at);
let rest = std::str::from_utf8(pdf.get(at..end).ok_or_else(|| io::Error::other("short PDF info value"))?)?;
let hex = rest.trim_start().strip_prefix("<FEFF").ok_or_else(|| io::Error::other("missing UTF-16 marker"))?;
let end = hex.find('>').ok_or_else(|| io::Error::other("missing UTF-16 terminator"))?;
let hex = hex.get(..end).ok_or_else(|| io::Error::other("invalid UTF-16 range"))?;
let units: Vec<u16> = (0..hex.len()).step_by(4).map(|i| u16::from_str_radix(hex.get(i..i + 4).unwrap_or(""), 16)).collect::<Result<_, _>>()?;
Ok(String::from_utf16(&units)?)
}
#[test]
fn info_strings_with_non_ascii_are_utf16be() -> Result<(), Box<dyn Error>> {
let mut doc = PdfDoc::new();
doc.add_page(200.0, 200.0);
doc.info.title = "Übersicht €5 – “Q1” 日本 😀".into();
doc.info.author = "Müller & Søn".into();
let pdf = doc.finish()?;
assert_eq!(utf16_entry(&pdf, "/Title")?, "Übersicht €5 – “Q1” 日本 😀");
assert_eq!(utf16_entry(&pdf, "/Author")?, "Müller & Søn");
Ok(())
}
#[test]
fn ascii_info_strings_stay_literal_and_escaped() {
let mut doc = PdfDoc::new();
doc.add_page(200.0, 200.0);
doc.info.title = r"Q1 (draft) a\b".into();
let pdf = doc.finish().unwrap();
assert!(find(&pdf, br"/Title (Q1 \(draft\) a\\b)").is_some());
assert!(find(&pdf, b"/Producer (GridCraft PDF)").is_some());
}
#[test]
fn info_strings_are_capped() -> Result<(), Box<dyn Error>> {
let mut doc = PdfDoc::new();
doc.add_page(200.0, 200.0);
doc.info.title = "日".repeat(100_000);
let pdf = doc.finish()?;
assert_eq!(utf16_entry(&pdf, "/Title")?.chars().count(), MAX_INFO_CHARS);
Ok(())
}
#[test]
fn cjk_text_is_not_replaced_by_question_marks() -> Result<(), Box<dyn Error>> {
let mut doc = PdfDoc::new();
let p = doc.add_page(612.0, 792.0);
p.text(10.0, 20.0, 10.0, Font::Helvetica, [0, 0, 0], "签字清单");
p.text(10.0, 40.0, 10.0, Font::Helvetica, [0, 0, 0], "No. 编号 2");
let pdf = doc.finish()?;
check_xref(&pdf)?;
assert!(find(&pdf, b"(????) Tj").is_none(), "CJK text written as question marks");
assert!(find(&pdf, b"<7B7E5B576E055355> Tj").is_some());
assert!(find(&pdf, b"(No. ) Tj").is_some());
assert!(find(&pdf, b"<7F1653F7> Tj").is_some());
assert!(find(&pdf, b"( 2) Tj").is_some());
assert!(find(&pdf, b"/Encoding /UniGB-UTF16-H").is_some());
// Measured as full-width glyphs, matching the CID font's default width.
assert_eq!(text_width(Font::Helvetica, 10.0, "签字"), 20.0);
Ok(())
}
#[test]
fn arabic_is_shaped_and_preserved_or_falls_back_without_a_font() {
let text = "مَرْحَبًا 123 (ABC)";
let mut doc = PdfDoc::new();
let page = doc.add_page(600.0, 300.0);
page.text(30.0, 70.0, 20.0, Font::Helvetica, [0, 0, 0], text);
let layout = arabic::layout(Font::Helvetica, text, TextDirection::Auto);
let Ok(layout) = layout else {
assert!(doc.missing_arabic_font());
check_xref(&doc.finish().unwrap()).unwrap();
return;
};
assert!(layout.width > 0.0);
assert!((text_width(Font::Helvetica, 20.0, text) - layout.width * 0.02).abs() < 0.001);
let pdf = doc.finish().unwrap();
check_xref(&pdf).unwrap();
assert_eq!(utf16_entry(&pdf, "/ActualText").unwrap(), text);
assert!(find(&pdf, b"/Subtype /Type3").is_some());
assert!(find(&pdf, b"/ToUnicode").is_some());
assert!(find(&pdf, b"beginbfchar").is_some());
assert!(find(&pdf, b"(?) Tj").is_none());
assert!(find(&pdf, b"/UniGB-UTF16-H").is_none(), "Arabic is never set in the CJK font");
}
#[test]
fn latin_inside_arabic_text_declares_its_page_font() {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return;
}
let mut doc = PdfDoc::new();
doc.add_page(600.0, 300.0).text(30.0, 70.0, 20.0, Font::Helvetica, [0, 0, 0], "مرحبا\u{2028}عالم");
let pdf = doc.finish().unwrap();
check_xref(&pdf).unwrap();
assert!(find(&pdf, b"/F1 20 Tf").is_some(), "the line break is drawn as a Helvetica space");
assert!(find(&pdf, b"/Font << /F1 ").is_some(), "the page declares the font its Latin run uses");
}
#[test]
fn cjk_inside_arabic_text_uses_the_cid_font() {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return;
}
let text = "مرحبا 编号";
let mut doc = PdfDoc::new();
doc.add_page(600.0, 300.0).text(30.0, 70.0, 20.0, Font::Helvetica, [0, 0, 0], text);
let pdf = doc.finish().unwrap();
check_xref(&pdf).unwrap();
assert!(find(&pdf, b"<7F1653F7> Tj").is_some(), "the CJK run is set in the CID font");
assert!(find(&pdf, b"/Encoding /UniGB-UTF16-H").is_some(), "the page declares the CID font");
assert_eq!(utf16_entry(&pdf, "/ActualText").unwrap(), text);
assert!(text_width(Font::Helvetica, 20.0, text) >= text_width(Font::Helvetica, 20.0, "مرحبا") + 40.0, "two full-width ideographs");
for (text, cid_run) in [("مرحبا 😀", &b"<D83DDE00> Tj"[..]), ("مرحبا Привет", &b"<041F04400438043204350442> Tj"[..])] {
let mut uncovered = PdfDoc::new();
uncovered.add_page(600.0, 300.0).text(30.0, 70.0, 20.0, Font::Helvetica, [0, 0, 0], text);
assert!(!uncovered.missing_arabic_font());
let pdf = uncovered.finish().unwrap();
check_xref(&pdf).unwrap();
assert!(find(&pdf, cid_run).is_some(), "{text}: characters the Arabic face lacks fall back like non-Arabic text");
assert_eq!(utf16_entry(&pdf, "/ActualText").unwrap(), text);
}
}
#[test]
fn oversized_arabic_text_is_an_error_instead_of_partial_pdf() {
let mut doc = PdfDoc::new();
doc.add_page(600.0, 300.0).text(0.0, 50.0, 10.0, Font::Helvetica, [0, 0, 0], &"ب".repeat(65_537));
if doc.missing_arabic_font() {
check_xref(&doc.finish().unwrap()).unwrap();
return;
}
assert!(doc.finish().unwrap_err().to_string().contains("128 KiB"));
}
#[test]
fn arabic_joining_marks_styles_and_rotation() {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return;
}
for (text, expected) in [("مرحبا 123 (ABC)", "(ABC)"), ("مرحبا [ABC]", "[ABC]"), ("مرحبا <ABC>", "<ABC>")] {
let mixed = arabic::layout(Font::Helvetica, text, TextDirection::Auto).unwrap();
let latin: String = mixed
.items
.iter()
.filter_map(|item| match item {
arabic::Item::Latin { text, .. } => Some(text.as_str()),
_ => None,
})
.collect();
if !latin.is_empty() {
assert_eq!(latin, expected);
}
}
let mut metrics = PdfDoc::new();
let (ascent, descent) = metrics.add_page(100.0, 100.0).text_vertical_extents(Font::Helvetica, 20.0, "كمثرى").unwrap();
assert!(ascent > 0.0 && descent > 20.0 * 0.22, "Arabic descenders exceed the old Latin baseline allowance");
assert!(
metrics.page_mut(0).unwrap().text_vertical_extents(Font::Helvetica, 20.0, "مرحبا 123 (ABC)").is_some(),
"spaces in variable fonts have empty outlines"
);
metrics.finish().unwrap();
let joined = arabic::layout(Font::Helvetica, "سلام", TextDirection::Auto).unwrap();
let separate_width: f32 = "سلام".chars().map(|c| text_width(Font::Helvetica, 1000.0, &c.to_string())).sum();
assert!((joined.width - separate_width).abs() > 10.0, "joining changes advances");
let marked = arabic::layout(Font::Helvetica, "مَرْحَبًا", TextDirection::Auto).unwrap();
let plain = arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).unwrap();
assert!(marked.items.len() > plain.items.len());
assert!(marked.items.iter().any(|item| matches!(item, arabic::Item::Glyph { y, .. } if *y != 0.0)));
let bold_available = match arabic::layout(Font::HelveticaBold, "مرحبا", TextDirection::Auto) {
Ok(bold) if arabic::bold_face_is_synthetic() => {
assert!(bold.width >= plain.width, "synthetic bold keeps the regular advances");
true
}
Ok(bold) => {
assert!(bold.width > plain.width, "bold metrics use the bold font instance");
true
}
Err(e) => {
assert!(arabic::ARABIC_FONTS.is_empty(), "a bundled face always serves bold text: {e:?}");
false
}
};
let mut regular = PdfDoc::new();
regular.add_page(500.0, 300.0).text(30.0, 60.0, 20.0, Font::Helvetica, [0, 0, 0], "مرحبا");
let regular = regular.finish().unwrap();
let mut italic = PdfDoc::new();
italic.add_page(500.0, 300.0).text(30.0, 60.0, 20.0, Font::HelveticaOblique, [0, 0, 0], "مرحبا");
let italic = italic.finish().unwrap();
assert_ne!(regular, italic, "italic shears the actual outlines");
let rotated_font = if bold_available { Font::HelveticaBoldOblique } else { Font::HelveticaOblique };
let mut rotated = PdfDoc::new();
rotated.add_page(500.0, 300.0).text_rotated(Point::new(100.0, 100.0), 20.0, rotated_font, [0, 0, 0], "مرحبا 123", -std::f32::consts::FRAC_PI_2);
let rotated = rotated.finish().unwrap();
check_xref(&rotated).unwrap();
assert_eq!(utf16_entry(&rotated, "/ActualText").unwrap(), "مرحبا 123");
assert!(find(&rotated, b"0 1 -1 0 100 200 cm").is_some());
}
#[test]
fn line_breaks_in_arabic_text_draw_as_spaces() {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return;
}
for (text, direction) in ["مرحبا\r\nعالم", "مرحبا\u{2028}عالم", "مرحبا\u{2029}ABC\r"]
.into_iter()
.flat_map(|text| [TextDirection::Auto, TextDirection::LeftToRight, TextDirection::RightToLeft].map(|direction| (text, direction)))
{
let layout = arabic::layout(Font::Helvetica, text, direction).unwrap();
for item in &layout.items {
if let arabic::Item::Latin { text: drawn, .. } = item {
assert!(!drawn.chars().any(|ch| matches!(ch, '\n' | '\r' | '\u{2028}' | '\u{2029}')), "{drawn:?} from {text:?}");
}
}
}
let drawn = |text: &str| format!("{:?}", arabic::layout(Font::Helvetica, text, TextDirection::RightToLeft).unwrap().items);
assert_eq!(drawn("مرحبا\u{2029}عالم"), drawn("مرحبا عالم"), "a paragraph separator keeps right-to-left reading order");
}
#[test]
fn arabic_text_respects_the_save_nesting_limit() -> Result<(), Box<dyn Error>> {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return Ok(());
}
let mut d = PdfDoc::new();
let p = d.add_page(100.0, 100.0);
for _ in 0..28 {
p.save();
}
p.text(10.0, 50.0, 12.0, Font::Helvetica, [0, 0, 0], "مرحبا");
assert_eq!(interpret(&p.content).max_depth, 28);
p.restore();
p.text(10.0, 50.0, 12.0, Font::Helvetica, [0, 0, 0], "مرحبا");
assert!(p.content.contains("/ActualText"));
check_xref(&d.finish()?)?;
Ok(())
}
#[test]
fn arabic_subsets_split_after_255_character_codes() -> Result<(), Box<dyn Error>> {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return Ok(());
}
let mut doc = PdfDoc::new();
let page = doc.add_page(600.0, 300.0);
let marks = ['َ', 'ُ', 'ِ', 'ّ', 'ْ', 'ً', 'ٌ', 'ٍ'];
for i in 0..260 {
let text = format!("ب{}{}{}", marks[i % 8], marks[(i / 8) % 8], marks[(i / 64) % 8]);
page.text(20.0, 50.0, 10.0, Font::Helvetica, [0, 0, 0], &text);
}
let pdf = doc.finish().unwrap();
check_xref(&pdf).unwrap();
assert!(find(&pdf, b"/A2 ").is_some());
assert!(find(&pdf, b"/LastChar 255").is_some());
assert!(find(&pdf, b"<100> Tj").is_none(), "Type3 codes are always one byte");
Ok(())
}
#[test]
fn spreadsheet_context_is_first_character_not_first_strong() {
use TextDirection::{Auto, Context, LeftToRight as Ltr, RightToLeft as Rtl};
for (text, expected) in [(" مرحبا", Rtl), ("123 مرحبا", Ltr), ("(مرحبا)", Ltr), (" ١٢٣ مرحبا", Ltr), ("\t\n", Ltr)] {
assert_eq!(Context.resolve(text), expected, "{text}");
}
assert_eq!(Auto.resolve("123 مرحبا"), Rtl);
assert_eq!(Auto.resolve("(مرحبا)"), Rtl);
}
#[test]
fn explicit_rtl_standard_text_reorders_without_an_arabic_font() {
let source = "ABC !";
let mut doc = PdfDoc::new();
let page = doc.add_page(300.0, 100.0);
page.text_with_direction(Point::new(10.0, 30.0), 12.0, Font::Helvetica, [0, 0, 0], source, TextDirection::RightToLeft);
assert!(page.content.contains("(! ABC) Tj"), "{}", page.content);
let mut objects = craft_pdf::classic::Writer::with_capacity(0).unwrap();
let mut next = 4;
assert!(page.arabic.write_objects(&mut next, &mut objects).unwrap().is_empty());
assert_eq!(next, 4, "Latin-only RTL text must not allocate Arabic font objects");
assert_eq!(text_width_with_direction(Font::Helvetica, 12.0, source, TextDirection::RightToLeft), text_width(Font::Helvetica, 12.0, source));
let pdf = doc.finish().unwrap();
assert_eq!(utf16_entry(&pdf, "/ActualText").unwrap(), source);
assert!(find(&pdf, b"/Subtype /Type3").is_none());
let mut huge = PdfDoc::new();
huge.add_page(300.0, 100.0).text_with_direction(
Point::new(10.0, 30.0),
12.0,
Font::Helvetica,
[0, 0, 0],
&"A".repeat(128 * 1024 + 1),
TextDirection::RightToLeft,
);
assert!(huge.finish().unwrap_err().to_string().contains("128 KiB"));
}
#[test]
fn arabic_explicit_base_changes_visual_order_and_preserves_logical_text() {
if arabic::layout(Font::Helvetica, "مرحبا", TextDirection::Auto).is_err() && arabic::ARABIC_FONTS.is_empty() {
return;
}
let sources = |text: &str, direction| {
arabic::layout(Font::Helvetica, text, direction)
.unwrap()
.items
.into_iter()
.map(|item| match item {
arabic::Item::Glyph { source, .. } => source,
arabic::Item::Latin { text, .. } | arabic::Item::Cid { text, .. } => text,
})
.collect::<String>()
};
let text = "مرحبا ABC";
let ltr = sources(text, TextDirection::LeftToRight);
let rtl = sources(text, TextDirection::RightToLeft);
assert!(ltr.ends_with("ABC"), "{ltr}");
assert!(rtl.starts_with("ABC"), "{rtl}");
assert_ne!(ltr, rtl);
assert_eq!(sources("123 مرحبا", TextDirection::Context), sources("123 مرحبا", TextDirection::LeftToRight));
let mut documents = Vec::new();
for direction in [TextDirection::LeftToRight, TextDirection::RightToLeft] {
let mut doc = PdfDoc::new();
doc.add_page(300.0, 100.0).text_rotated_with_direction(
Baseline { origin: Point::new(30.0, 70.0), angle: 0.3 },
20.0,
Font::Helvetica,
[0, 0, 0],
text,
direction,
);
let pdf = doc.finish().unwrap();
assert_eq!(utf16_entry(&pdf, "/ActualText").unwrap(), text);
documents.push(pdf);
}
assert_ne!(documents[0], documents[1]);
}
#[test]
fn many_alternating_runs_share_one_text_matrix() {
let mut doc = PdfDoc::new();
let p = doc.add_page(612.0, 792.0);
p.text(10.0, 20.0, 10.0, Font::Helvetica, [0, 0, 0], &"a\u{4e2d}".repeat(2000));
let pdf = doc.finish().unwrap();
let count = |needle: &[u8]| pdf.windows(needle.len()).filter(|w| *w == needle).count();
assert_eq!(count(b" Tm\n"), 1, "the position is set once, before the first run");
assert_eq!(count(b" Tf\n"), 4000, "every run selects its font");
assert_eq!(count(b" Tj\n"), 4000);
}
#[test]
fn symbol_font_draws_maths_in_its_own_encoding() -> Result<(), Box<dyn Error>> {
let mut doc = PdfDoc::new();
let p = doc.add_page(200.0, 200.0);
p.text(10.0, 50.0, 12.0, Font::Symbol, [0, 0, 0], "\u{2211}\u{03B1}\u{2264}\u{221E}x");
p.text(10.0, 80.0, 12.0, Font::TimesItalic, [0, 0, 0], "x");
let pdf = doc.finish()?;
let s = String::from_utf8_lossy(&pdf);
assert!(s.contains("/BaseFont /Symbol >>"), "Symbol has no WinAnsi encoding");
assert!(s.contains("/BaseFont /Times-Italic /Encoding /WinAnsiEncoding"));
// The sum, alpha, less-or-equal and infinity codes; x is not in Symbol and becomes `?`.
assert!(s.contains("(\\345a\\243\\245?) Tj"), "{s}");
check_xref(&pdf)?;
assert!(Font::Symbol.can_encode('\u{2211}') && !Font::Symbol.can_encode('x'));
assert!(Font::TimesRoman.can_encode('x') && !Font::TimesRoman.can_encode('\u{2211}'));
assert_eq!(text_width(Font::Symbol, 10.0, "\u{2211}"), 7.13);
Ok(())
}
#[test]
fn symbol_text_is_never_shaped_as_arabic() -> Result<(), Box<dyn Error>> {
let mut doc = PdfDoc::new();
let page = doc.add_page(200.0, 200.0);
assert_eq!(page.text_vertical_extents(Font::Symbol, 12.0, "\u{03B1}ب"), None);
page.text(10.0, 50.0, 12.0, Font::Symbol, [0, 0, 0], "\u{03B1}ب");
let pdf = doc.finish()?;
check_xref(&pdf)?;
assert!(find(&pdf, b"(a?) Tj").is_some());
assert!(find(&pdf, b"/ActualText").is_none());
assert_eq!(text_width(Font::Symbol, 10.0, "\u{03B1}ب"), f32::from(Font::Symbol.char_width('\u{03B1}') + Font::Symbol.char_width('ب')) / 100.0);
Ok(())
}
#[test]
fn shared_run_length_preserves_pixels_at_packet_boundaries() {
for len in [0, 1, 2, 3, 127, 128, 129, 255, 256, 257, 1024] {
for seed in [0u8, 127, 128, 255] {
let repeats = vec![seed; len];
let literals: Vec<u8> = (0..len).map(|i| seed.wrapping_add(i as u8)).collect();
let pairs: Vec<u8> = (0..len).map(|i| (i / 2) as u8).collect();
for pixels in [repeats, literals, pairs] {
let encoded = run_length(&pixels);
assert_eq!(encoded.last(), Some(&128));
assert_eq!(rle_decode(&encoded), pixels);
}
}
}
// Two equal bytes may now terminate a literal packet. PDF pixel values stay exact.
assert_eq!(run_length(&[1, 2, 2, 3]), [0, 1, 255, 2, 0, 3, 128]);
}