ttf-parser 0.25.1

A high-level, safe, zero-allocation font parser for TrueType, OpenType, and AAT.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::num::NonZeroU16;
use ttf_parser::GlyphId;
use ttf_parser::hmtx::Table;
use crate::{convert, Unit::*};

macro_rules! nzu16 {
    ($n:expr) => { NonZeroU16::new($n).unwrap() };
}

#[test]
fn simple_case() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]
    ]);

    let table = Table::parse(1, nzu16!(1), &data).unwrap();
    assert_eq!(table.advance(GlyphId(0)), Some(1));
    assert_eq!(table.side_bearing(GlyphId(0)), Some(2));
}

#[test]
fn empty() {
    assert!(Table::parse(1, nzu16!(1), &[]).is_none());
}

#[test]
fn zero_metrics() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]
    ]);

    assert!(Table::parse(0, nzu16!(1), &data).is_none());
}

#[test]
fn smaller_than_glyphs_count() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]

        Int16(3), // side bearing [1]
    ]);

    let table = Table::parse(1, nzu16!(2), &data).unwrap();
    assert_eq!(table.advance(GlyphId(0)), Some(1));
    assert_eq!(table.side_bearing(GlyphId(0)), Some(2));
    assert_eq!(table.advance(GlyphId(1)), Some(1));
    assert_eq!(table.side_bearing(GlyphId(1)), Some(3));
}

#[test]
fn no_additional_side_bearings() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]

        // A single side bearing should be present here.
        // We should simply ignore it and not return None during Table parsing.
    ]);

    let table = Table::parse(1, nzu16!(2), &data).unwrap();
    assert_eq!(table.advance(GlyphId(0)), Some(1));
    assert_eq!(table.side_bearing(GlyphId(0)), Some(2));
}

#[test]
fn less_metrics_than_glyphs() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]

        UInt16(3), // advance width [1]
        Int16(4), // side bearing [1]

        Int16(5), // side bearing [2]
    ]);

    let table = Table::parse(2, nzu16!(1), &data).unwrap();
    assert_eq!(table.side_bearing(GlyphId(0)), Some(2));
    assert_eq!(table.side_bearing(GlyphId(1)), Some(4));
    assert_eq!(table.side_bearing(GlyphId(2)), None);
}

#[test]
fn glyph_out_of_bounds_0() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]
    ]);

    let table = Table::parse(1, nzu16!(1), &data).unwrap();
    assert_eq!(table.advance(GlyphId(0)), Some(1));
    assert_eq!(table.side_bearing(GlyphId(0)), Some(2));
    assert_eq!(table.advance(GlyphId(1)), None);
    assert_eq!(table.side_bearing(GlyphId(1)), None);
}

#[test]
fn glyph_out_of_bounds_1() {
    let data = convert(&[
        UInt16(1), // advance width [0]
        Int16(2), // side bearing [0]

        Int16(3), // side bearing [1]
    ]);

    let table = Table::parse(1, nzu16!(2), &data).unwrap();
    assert_eq!(table.advance(GlyphId(1)), Some(1));
    assert_eq!(table.side_bearing(GlyphId(1)), Some(3));
    assert_eq!(table.advance(GlyphId(2)), None);
    assert_eq!(table.side_bearing(GlyphId(2)), None);
}