b45255bb6fe2
fontdb_fallback_tests.rs
//! The fallback fonts text draws missing characters with: each family reads the one face nearest
//! the run's style (Noto Sans CJK is seven files of 16โ20 MB, read whole until now), families
//! naming the faces of one file share its bytes, and the faces are worked out once per style until
//! fonts change, not for every text shaped.
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use super::{Face, FontBytes, FontDb, LocalFont, Pending};
/// A synthetic TrueType font: printable ASCII as outline-less glyphs 500 of 1000 units wide.
fn synthetic_font(family: &str) -> Vec<u8> {
let be16 = |v: &mut Vec<u8>, x: u16| v.extend_from_slice(&x.to_be_bytes());
let glyphs: u16 = 1 + (0x7E - 0x20 + 1);
let mut head = Vec::new();
for x in [0x0001_0000u32, 0x0001_0000, 0, 0x5F0F_3CF5] {
head.extend_from_slice(&x.to_be_bytes());
}
be16(&mut head, 0); // flags
be16(&mut head, 1000); // unitsPerEm
head.extend_from_slice(&[0; 16]); // created, modified
for x in [0u16, (-200i16) as u16, 500, 800, 0, 8, 2, 0, 0] {
be16(&mut head, x); // bbox, macStyle, lowestRecPPEM, direction hint, short loca, glyph format
}
let mut hhea = 0x0001_0000u32.to_be_bytes().to_vec();
for x in [800u16, (-200i16) as u16, 0, 500, 0, 0, 500, 1, 0, 0, 0, 0, 0, 0, 0, glyphs] {
be16(&mut hhea, x);
}
let mut maxp = 0x0001_0000u32.to_be_bytes().to_vec();
be16(&mut maxp, glyphs);
for x in [0u16, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] {
be16(&mut maxp, x);
}
let mut hmtx = Vec::new();
for _ in 0..glyphs {
be16(&mut hmtx, 500);
be16(&mut hmtx, 0);
}
let loca = vec![0; 2 * (usize::from(glyphs) + 1)];
let glyf = vec![0; 4];
// cmap: one Windows Unicode BMP subtable, format 4, 0x20..=0x7E โ glyphs 1.. plus the end segment.
let mut cmap = Vec::new();
for x in [0u16, 1, 3, 1, 0, 12] {
be16(&mut cmap, x);
}
for x in [4u16, 32, 0, 4, 4, 1, 0, 0x7E, 0xFFFF, 0, 0x20, 0xFFFF, (1i16 - 0x20) as u16, 1, 0, 0] {
be16(&mut cmap, x);
}
let strings = [(1u16, family.to_string()), (2, "Regular".into()), (6, family.replace(' ', "") + "-Regular")];
let mut name = Vec::new();
be16(&mut name, 0);
be16(&mut name, strings.len() as u16);
be16(&mut name, 6 + 12 * strings.len() as u16);
let mut storage = Vec::new();
for (id, s) in &strings {
let utf16: Vec<u8> = s.encode_utf16().flat_map(u16::to_be_bytes).collect();
for x in [3u16, 1, 0x409, *id, utf16.len() as u16, storage.len() as u16] {
be16(&mut name, x);
}
storage.extend(utf16);
}
name.extend(storage);
let mut post = 0x0003_0000u32.to_be_bytes().to_vec();
post.extend_from_slice(&[0; 28]);
let tables: [(&[u8; 4], Vec<u8>); 9] = [
(b"cmap", cmap),
(b"glyf", glyf),
(b"head", head),
(b"hhea", hhea),
(b"hmtx", hmtx),
(b"loca", loca),
(b"maxp", maxp),
(b"name", name),
(b"post", post),
];
let mut font = 0x0001_0000u32.to_be_bytes().to_vec();
for x in [tables.len() as u16, 128, 3, 16] {
be16(&mut font, x);
}
let mut offset = 12 + 16 * tables.len();
for (tag, data) in &tables {
font.extend_from_slice(*tag);
font.extend_from_slice(&0u32.to_be_bytes());
font.extend_from_slice(&(offset as u32).to_be_bytes());
font.extend_from_slice(&(data.len() as u32).to_be_bytes());
offset += data.len().next_multiple_of(4);
}
for (_, data) in &tables {
font.extend_from_slice(data);
font.resize(font.len().next_multiple_of(4), 0);
}
font
}
static NEXT: AtomicU64 = AtomicU64::new(0);
/// A folder of synthetic font files, removed afterwards.
struct Fonts(PathBuf);
impl Fonts {
fn new() -> Self {
let dir = std::env::temp_dir().join(format!("fig-fallback-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
std::fs::create_dir_all(&dir).unwrap();
Self(dir)
}
/// Write a font file named `file`.
fn file(&self, file: &str) -> PathBuf {
let path = self.0.join(file);
std::fs::write(&path, synthetic_font("Synthetic")).unwrap();
path
}
}
impl Drop for Fonts {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// Offer `family`'s faces as the font scan would: by style, from their files.
fn scanned(db: &mut FontDb, family: &str, faces: &[(&str, &Path)]) {
let entries =
faces.iter().map(|(style, path)| Pending { path: path.to_path_buf(), index: 0, style: (*style).into(), postscript: None, local: None });
db.merge_scan(BTreeMap::from([(family.to_lowercase(), (family.to_string(), entries.collect()))]));
}
/// The styles of `family` not read yet.
fn waiting(db: &FontDb, family: &str) -> Vec<String> {
db.pending.get(&family.to_lowercase()).map(|(_, v)| v.iter().map(|e| e.style.clone()).collect()).unwrap_or_default()
}
fn named(faces: &[Arc<Face>]) -> Vec<(String, String)> {
faces.iter().map(|f| (f.family.clone(), f.style.clone())).collect()
}
const CJK: &str = "Noto Sans CJK SC";
#[test]
fn a_fallback_family_reads_only_the_face_nearest_each_style() {
let fonts = Fonts::new();
let styles = ["Thin", "Light", "DemiLight", "Regular", "Medium", "Bold", "Black"];
let files: Vec<PathBuf> = styles.iter().map(|s| fonts.file(&format!("{s}.ttf"))).collect();
let faces: Vec<(&str, &Path)> = styles.iter().copied().zip(files.iter().map(PathBuf::as_path)).collect();
let mut db = FontDb::default();
scanned(&mut db, CJK, &faces);
let regular = db.fallbacks();
assert_eq!(named(®ular), [(CJK.to_string(), "Regular".to_string())]);
assert_eq!(waiting(&db, CJK), ["Thin", "Light", "DemiLight", "Medium", "Bold", "Black"], "one file read, not seven");
// A bold run reads the bold face, once.
let bold = db.fallbacks_for("Bold");
assert_eq!(named(&bold), [(CJK.to_string(), "Bold".to_string())]);
db.fallbacks_for("Bold");
assert_eq!(waiting(&db, CJK), ["Thin", "Light", "DemiLight", "Medium", "Black"]);
// A style no nearer than a face read already reads nothing: SemiBold is as far from Medium.
db.fallbacks_for("SemiBold");
assert_eq!(waiting(&db, CJK).len(), 5);
// Used by name, the family reads the rest.
assert!(db.find(CJK, "Light").is_some());
assert!(waiting(&db, CJK).is_empty());
}
#[test]
fn fallback_faces_are_worked_out_once_until_fonts_change() {
let fonts = Fonts::new();
let regular = fonts.file("Regular.ttf");
let mut db = FontDb::default();
scanned(&mut db, CJK, &[("Regular", regular.as_path())]);
let first = db.fallbacks();
let generation = db.generation;
// Every text shaped asks again: the same faces, with nothing looked up or read.
for _ in 0..3 {
let again = db.fallbacks();
assert!(first.len() == again.len() && first.iter().zip(&again).all(|(a, b)| Arc::ptr_eq(a, b)));
}
assert_eq!(db.generation, generation, "nothing read or looked up again");
// A fallback family installed since joins in its place.
scanned(&mut db, "Noto Sans Arabic", &[("Regular", fonts.file("Arabic.ttf").as_path())]);
let families: Vec<String> = db.fallbacks().iter().map(|f| f.family.clone()).collect();
assert_eq!(families, [CJK, "Noto Sans Arabic"]);
}
#[test]
fn families_naming_the_faces_of_one_file_share_its_bytes() {
// Noto Sans CJK SC and KR are faces of the same collections.
let fonts = Fonts::new();
let file = fonts.file("NotoSansCJK-Regular.ttc");
let mut db = FontDb::default();
scanned(&mut db, CJK, &[("Regular", file.as_path())]);
scanned(&mut db, "Noto Sans CJK KR", &[("Regular", file.as_path())]);
let faces = db.fallbacks();
let shared = |a: &Arc<Face>, b: &Arc<Face>| matches!((&a.bytes, &b.bytes), (FontBytes::Shared(a), FontBytes::Shared(b)) if Arc::ptr_eq(a, b));
let [sc, kr] = faces.as_slice() else { panic!("{:?}", named(&faces)) };
assert_eq!((sc.family.as_str(), kr.family.as_str()), (CJK, "Noto Sans CJK KR"));
assert!(shared(sc, kr), "the file is read once");
// A file that changed length since is read again.
let mut grown = std::fs::read(&file).unwrap();
grown.extend_from_slice(&[0; 4]);
std::fs::write(&file, grown).unwrap();
scanned(&mut db, "Noto Sans KR", &[("Regular", file.as_path())]);
let faces = db.fallbacks();
let kr2 = faces.iter().find(|f| f.family == "Noto Sans KR").unwrap();
assert!(!shared(sc, kr2));
}
#[test]
fn a_face_that_cant_be_read_gives_way_to_the_next_nearest() {
let fonts = Fonts::new();
let missing = fonts.0.join("Regular.ttf");
let medium = fonts.file("Medium.ttf");
let mut db = FontDb::default();
let bold = fonts.file("Bold.ttf");
scanned(&mut db, "DejaVu Sans", &[("Regular", missing.as_path()), ("Bold", bold.as_path()), ("Medium", medium.as_path())]);
assert_eq!(named(&db.fallbacks()), [("DejaVu Sans".to_string(), "Medium".to_string())]);
assert_eq!(waiting(&db, "DejaVu Sans"), ["Bold"]);
}
#[test]
fn a_run_reads_the_face_that_slants_as_it_does() {
// DejaVu Sans names its upright face Book and its slanted ones Oblique: a regular run reads
// Book, not Oblique, and a bold italic one Bold Oblique, not Bold.
let fonts = Fonts::new();
let styles = ["Bold", "Bold Oblique", "ExtraLight", "Oblique", "Book"];
let files: Vec<PathBuf> = styles.iter().map(|s| fonts.file(&format!("DejaVuSans-{s}.ttf"))).collect();
let faces: Vec<(&str, &Path)> = styles.iter().copied().zip(files.iter().map(PathBuf::as_path)).collect();
let mut db = FontDb::default();
scanned(&mut db, "DejaVu Sans", &faces);
assert_eq!(named(&db.fallbacks()), [("DejaVu Sans".to_string(), "Book".to_string())]);
db.fallbacks_for("Bold Italic");
assert_eq!(waiting(&db, "DejaVu Sans"), ["Bold", "ExtraLight", "Oblique"]);
}
#[test]
fn a_browser_fallback_font_is_asked_for_once_per_style() {
let local =
|id: usize, style: &str| LocalFont { id, family: "Noto Sans Thai".into(), style: style.into(), postscript: format!("NotoSansThai-{style}") };
let mut db = FontDb::default();
db.add_local(vec![local(1, "Bold"), local(2, "Regular")]);
// Nothing draws until the bytes come; the regular face is asked for, not the bold one.
assert!(db.fallbacks().is_empty());
assert_eq!(std::mem::take(&mut db.wanted), [2]);
let generation = db.generation;
db.fallbacks();
db.fallbacks();
assert!(db.wanted.is_empty(), "asked for once");
assert_eq!(db.generation, generation);
// A bold run asks for the bold face.
db.fallbacks_for("Bold");
assert_eq!(std::mem::take(&mut db.wanted), [1]);
assert_eq!(db.load_local(2, synthetic_font("Noto Sans Thai")).as_deref(), Some("Noto Sans Thai"));
assert_eq!(named(&db.fallbacks()), [("Noto Sans Thai".to_string(), "Regular".to_string())]);
assert!(db.wanted.is_empty());
}
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.