94 lines
4.3 KiB
Rust
94 lines
4.3 KiB
Rust
//! Embedded fonts: licence flags and subsets a viewer can use.
|
|
|
|
use skrifa::MetadataProvider;
|
|
use skrifa::instance::{LocationRef, Size};
|
|
use skrifa::raw::types::Tag;
|
|
use skrifa::raw::{FontData, FontRead, TableProvider};
|
|
|
|
use super::embed::Embedding;
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn fs_type_flags_decide_the_embedding() {
|
|
assert_eq!(Embedding::from_fs_type(0), Embedding::Subset, "installable");
|
|
assert_eq!(Embedding::from_fs_type(0x0004), Embedding::Subset, "preview & print");
|
|
assert_eq!(Embedding::from_fs_type(0x0008), Embedding::Subset, "editable");
|
|
assert_eq!(Embedding::from_fs_type(0x0002), Embedding::Forbidden, "restricted");
|
|
assert_eq!(Embedding::from_fs_type(0x0006), Embedding::Subset, "the most permissive bit wins");
|
|
assert_eq!(Embedding::from_fs_type(0x0200), Embedding::Forbidden, "bitmaps only");
|
|
assert_eq!(Embedding::from_fs_type(0x0108), Embedding::Whole, "no subsetting");
|
|
}
|
|
|
|
#[test]
|
|
fn a_subset_holds_only_the_glyphs_used_and_maps_their_characters() {
|
|
let face = FontDb::global().face("Source Sans 3", "Regular").unwrap();
|
|
assert_eq!(face.embedding(), Embedding::Subset);
|
|
let e = face.embed(&['H', 'e', 'l', 'l', 'o', ' ']).unwrap();
|
|
assert!(e.subset && !e.cff);
|
|
assert!(e.data.len() * 20 < face.data().len(), "{} of {} bytes", e.data.len(), face.data().len());
|
|
let f = skrifa::FontRef::new(&e.data).unwrap();
|
|
// .notdef and the five characters' glyphs.
|
|
assert_eq!(f.maxp().unwrap().num_glyphs(), 6);
|
|
let map = f.charmap();
|
|
let metrics = f.glyph_metrics(Size::unscaled(), LocationRef::default());
|
|
for c in ['H', 'e', 'l', 'o', ' '] {
|
|
let g = map.map(c).unwrap_or_else(|| panic!("{c} mapped"));
|
|
assert_eq!(metrics.advance_width(g).unwrap() as f64, face.advance(face.glyph_for(c)), "{c}: same advance");
|
|
}
|
|
assert!(map.map('x').is_none(), "unused characters are left out");
|
|
let h = f.outline_glyphs().get(map.map('H').unwrap()).unwrap();
|
|
let mut pen = Commands::default();
|
|
h.draw(skrifa::outline::DrawSettings::unhinted(Size::unscaled(), LocationRef::default()), &mut pen).unwrap();
|
|
assert!(pen.0 > 4, "H keeps its outline");
|
|
// The tables a web viewer needs, the licence flags kept and the file checksum right.
|
|
for t in [b"cmap", b"OS/2", b"head", b"hhea", b"hmtx", b"maxp", b"name", b"post", b"glyf", b"loca"] {
|
|
assert!(f.table_data(Tag::new(t)).is_some(), "{}", String::from_utf8_lossy(t));
|
|
}
|
|
let os2 = f.os2().unwrap();
|
|
assert_eq!(os2.fs_type(), face.skrifa().unwrap().os2().unwrap().fs_type());
|
|
assert_eq!((os2.us_first_char_index(), os2.us_last_char_index()), (' ' as u16, 'o' as u16));
|
|
let (words, rest) = e.data.as_chunks::<4>();
|
|
assert!(rest.is_empty());
|
|
assert_eq!(words.iter().fold(0u32, |s, w| s.wrapping_add(u32::from_be_bytes(*w))), 0xb1b0_afba);
|
|
}
|
|
|
|
#[test]
|
|
fn cmaps_map_runs_and_characters_beyond_the_basic_plane() {
|
|
let face = FontDb::global().face("Inter", "Regular").unwrap();
|
|
let e = face.embed(&['A', 'B', 'z']).unwrap();
|
|
let f = skrifa::FontRef::new(&e.data).unwrap();
|
|
let cmap = f.cmap().unwrap();
|
|
let (a, b, z) = (cmap.map_codepoint('A').unwrap(), cmap.map_codepoint('B').unwrap(), cmap.map_codepoint('z').unwrap());
|
|
assert!(a != b && b != z && a.to_u32() != 0);
|
|
assert_eq!(cmap.map_codepoint('C'), None);
|
|
// No bundled face maps characters beyond the BMP: the table is checked on its own.
|
|
let raw = embed::cmap(&[(0x41, 1), (0x42, 2), (0x1f600, 3)]).unwrap();
|
|
let cmap = skrifa::raw::tables::cmap::Cmap::read(FontData::new(&raw)).unwrap();
|
|
assert_eq!(cmap.encoding_records().len(), 2, "format 4 and format 12");
|
|
for (c, g) in [('A', 1), ('B', 2), ('\u{1f600}', 3)] {
|
|
assert_eq!(cmap.map_codepoint(c).map(|g| g.to_u32()), Some(g), "{c}");
|
|
}
|
|
assert_eq!(cmap.map_codepoint('C'), None);
|
|
assert!(embed::cmap(&[]).is_none());
|
|
}
|
|
|
|
/// Counts outline commands.
|
|
#[derive(Default)]
|
|
struct Commands(usize);
|
|
|
|
impl skrifa::outline::OutlinePen for Commands {
|
|
fn move_to(&mut self, _: f32, _: f32) {
|
|
self.0 += 1;
|
|
}
|
|
fn line_to(&mut self, _: f32, _: f32) {
|
|
self.0 += 1;
|
|
}
|
|
fn quad_to(&mut self, _: f32, _: f32, _: f32, _: f32) {
|
|
self.0 += 1;
|
|
}
|
|
fn curve_to(&mut self, _: f32, _: f32, _: f32, _: f32, _: f32, _: f32) {
|
|
self.0 += 1;
|
|
}
|
|
fn close(&mut self) {}
|
|
}
|