read_fonts/tables/
trak.rs1include!("../../generated/generated_trak.rs");
4
5impl<'a> TrackData<'a> {
6 pub fn size_table(&self, offset_data: FontData<'a>) -> Option<&'a [BigEndian<Fixed>]> {
10 let mut cursor = offset_data
11 .split_off(self.size_table_offset() as usize)?
12 .cursor();
13 cursor.read_array(self.n_sizes() as usize).ok()
14 }
15}
16
17impl TrackTableEntry {
18 pub fn per_size_values<'a>(
23 &self,
24 offset_data: FontData<'a>,
25 n_sizes: u16,
26 ) -> Option<&'a [BigEndian<i16>]> {
27 let mut cursor = offset_data.split_off(self.offset() as usize)?.cursor();
28 cursor.read_array(n_sizes as usize).ok()
29 }
30}
31
32#[cfg(test)]
33mod tests {
34 use super::*;
35 use font_test_data::bebuffer::BeBuffer;
36
37 #[test]
38 fn parse_header() {
39 let table_data = example_track_table();
40 let trak = Trak::read(FontData::new(&table_data)).unwrap();
41 assert_eq!(trak.version(), MajorMinor::VERSION_1_0);
42 let _ = trak.horiz().unwrap().unwrap();
43 assert!(trak.vert().is_none());
44 }
45
46 #[test]
47 fn parse_tracks() {
48 let table_data = example_track_table();
49 let trak = Trak::read(FontData::new(&table_data)).unwrap();
50 let horiz = trak.horiz().unwrap().unwrap();
51 let track_table = horiz.track_table();
52 let expected_tracks = [
53 (Fixed::from_i32(-1), NameId::new(256), 52),
54 (Fixed::from_i32(0), NameId::new(258), 60),
55 (Fixed::from_i32(1), NameId::new(257), 56),
56 ];
57 let tracks = track_table
58 .iter()
59 .map(|track| (track.track(), track.name_index(), track.offset()))
60 .collect::<Vec<_>>();
61 assert_eq!(tracks, expected_tracks);
62 let expected_per_size_tracking_values = [[-15i16, -7], [0, 0], [50, 20]];
63 for (track, expected_values) in track_table.iter().zip(expected_per_size_tracking_values) {
64 let values = track
65 .per_size_values(trak.offset_data(), horiz.n_sizes())
66 .unwrap()
67 .iter()
68 .map(|v| v.get())
69 .collect::<Vec<_>>();
70 assert_eq!(values, expected_values);
71 }
72 }
73
74 #[test]
75 fn parse_per_size_values() {
76 let table_data = example_track_table();
77 let trak = Trak::read(FontData::new(&table_data)).unwrap();
78 let horiz = trak.horiz().unwrap().unwrap();
79 let track_table = horiz.track_table();
80 let expected_per_size_tracking_values = [[-15i16, -7], [0, 0], [50, 20]];
81 for (track, expected_values) in track_table.iter().zip(expected_per_size_tracking_values) {
82 let values = track
83 .per_size_values(trak.offset_data(), horiz.n_sizes())
84 .unwrap()
85 .iter()
86 .map(|v| v.get())
87 .collect::<Vec<_>>();
88 assert_eq!(values, expected_values);
89 }
90 }
91
92 #[test]
93 fn parse_sizes() {
94 let table_data = example_track_table();
95 let trak = Trak::read(FontData::new(&table_data)).unwrap();
96 let horiz = trak.horiz().unwrap().unwrap();
97 let size_table = horiz
98 .size_table(trak.offset_data())
99 .unwrap()
100 .iter()
101 .map(|v| v.get())
102 .collect::<Vec<_>>();
103 let expected_sizes = [Fixed::from_i32(12), Fixed::from_i32(24)];
104 assert_eq!(size_table, expected_sizes);
105 }
106
107 #[test]
108 fn insufficient_data() {
109 let mut table_data = example_track_table();
110 table_data.pop();
112 let trak = Trak::read(FontData::new(&table_data)).unwrap();
113 let horiz = trak.horiz().unwrap().unwrap();
114 let track_table = horiz.track_table();
115 let expected_per_size_tracking_values = [Some([-15i16, -7]), None, Some([50, 20])];
117 for (track, expected_values) in track_table.iter().zip(expected_per_size_tracking_values) {
118 let values = track
119 .per_size_values(trak.offset_data(), horiz.n_sizes())
120 .map(|values| values.iter().map(|v| v.get()).collect::<Vec<_>>());
121 assert_eq!(
122 values,
123 expected_values.map(|value| value.into_iter().collect())
124 );
125 }
126 }
127
128 #[test]
129 fn bad_offset() {
130 let mut table_data = example_track_table();
131 table_data[26] = 255;
133 let trak = Trak::read(FontData::new(&table_data)).unwrap();
134 let horiz = trak.horiz().unwrap().unwrap();
135 let track_table = horiz.track_table();
136 assert!(track_table[0]
137 .per_size_values(trak.offset_data(), horiz.n_sizes())
138 .is_none());
139 }
140
141 fn example_track_table() -> Vec<u8> {
143 let mut buf = BeBuffer::new();
144 buf = buf.push(MajorMinor::VERSION_1_0);
146 buf = buf.extend([0u16, 12, 0, 0]);
147 buf = buf.extend([3u16, 2]);
149 buf = buf.push(44u32);
150 buf = buf.push(0xFFFF0000u32).extend([256u16, 52]);
152 buf = buf.push(0x00000000u32).extend([258u16, 60]);
153 buf = buf.push(0x00010000u32).extend([257u16, 56]);
154 buf = buf.push(0x000C0000u32);
156 buf = buf.push(0x00180000u32);
157 buf = buf.extend([-15i16, -7, 50, 20, 0, 0]);
159 buf.to_vec()
160 }
161}