1687a9c05b0c
tests.rs
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]);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.